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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; 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                            ;;
;;                                                                 ;;
;;    Based on the algorithms used in 4.4BSD                       ;;
;;                                                                 ;;
;;          GNU GENERAL PUBLIC LICENSE                             ;;
;;             Version 2, June 1991                                ;;
;;                                                                 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 6710 $
 
TCP_BIT_NEEDOUTPUT      = 1 shl 0
TCP_BIT_TIMESTAMP       = 1 shl 1
TCP_BIT_DROPSOCKET      = 1 shl 2
TCP_BIT_FIN_IS_ACKED    = 1 shl 3
 
;-----------------------------------------------------------------;
;                                                                 ;
; TCP_input: Add a segment to the incoming TCP queue.             ;
;                                                                 ;
;  IN:  [esp] = ptr to buffer                                     ;
;       ebx = ptr to device struct                                ;
;       ecx = TCP segment size                                    ;
;       edx = ptr to IPv4 header                                  ;
;       esi = ptr to TCP segment                                  ;
;       edi = interface number*4                                  ;
;                                                                 ;
;  OUT: /                                                         ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
tcp_input:
 
; record the current time
        push    [timer_ticks]           ; in 1/100 seconds
        push    ebx ecx esi edx         ; mind the order (see TCP_queue_entry struct)
        mov     esi, esp
 
        push    edi
        add_to_queue TCP_queue, TCP_QUEUE_SIZE, sizeof.TCP_queue_entry, .fail
        pop     edi
        add     esp, sizeof.TCP_queue_entry
 
        inc     [TCP_segments_rx + edi]
 
        xor     edx, edx
        mov     eax, [TCP_input_event]
        mov     ebx, [eax + EVENT.id]
        xor     esi, esi
        call    raise_event
 
        ret
 
  .fail:
        pop     edi
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP incoming queue is full, discarding packet!\n"
 
        call    net_ptr_to_num4
        inc     [TCP_segments_missed + edi]
 
        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
 
locals
        dataoffset      dd ?
        timestamp       dd ?
        temp_bits       db ?
endl
 
        xor     esi, esi
        mov     ecx, MANUAL_DESTROY
        call    create_event
        mov     [TCP_input_event], eax
 
  .wait:
        mov     eax, [TCP_input_event]
        mov     ebx, [eax + EVENT.id]
        call    wait_event
 
  .loop:
        get_from_queue TCP_queue, TCP_QUEUE_SIZE, sizeof.TCP_queue_entry, .wait
 
        push    [esi + TCP_queue_entry.timestamp]
        pop     [timestamp]
        push    [esi + TCP_queue_entry.buffer_ptr]
 
        mov     ebx, [esi + TCP_queue_entry.device_ptr]
        mov     ecx, [esi + TCP_queue_entry.segment_size]
        mov     edi, [esi + TCP_queue_entry.ip_ptr]                     ; ptr to ipv4 header
        mov     esi, [esi + TCP_queue_entry.segment_ptr]                ; change esi last
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: size=%u time=%d\n", ecx, [timer_ticks]
 
        mov     edx, esi
 
; Verify the checksum (if not already done by hw)
 
        test    [ebx + NET_DEVICE.hwacc], NET_HWACC_TCP_IPv4_IN
        jnz     .checksum_ok
 
        push    ecx esi
        pushw   [esi + TCP_header.Checksum]
        mov     [esi + TCP_header.Checksum], 0
        tcp_checksum (edi+IPv4_header.SourceAddress), (edi+IPv4_header.DestinationAddress)
        pop     cx                              ; previous checksum
        cmp     cx, dx
        pop     edx ecx
        jne     .drop_no_socket
  .checksum_ok:
 
; 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
        jb      .drop_no_socket                 ; If not, drop the packet
        mov     [dataoffset], eax
 
        sub     ecx, eax                                                ; substract TCP header size from total segment size
        jb      .drop_no_socket                                         ; If total segment size is less then the advertised header size, drop packet
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: %u bytes of data\n", ecx
 
;-------------------------------------------
; Convert Big-endian values to little endian
 
        ntohd   [edx + TCP_header.SequenceNumber]
        ntohd   [edx + TCP_header.AckNumber]
 
        ntohw   [edx + TCP_header.Window]
        ntohw   [edx + TCP_header.UrgentPointer]
 
;-----------------------------------------------------------------------------------
;
; Find the socket pointer
;
;-----------------------------------------------------------------------------------
 
; IP Packet TCP Destination Port = local Port
; (IP Packet SenderAddress = Remote IP)  OR  (Remote IP = 0)
; (IP Packet TCP Source Port = remote Port) OR (remote Port = 0)
 
  .findpcb:
        pusha
        mov     ecx, socket_mutex
        call    mutex_lock
        popa
 
        mov     ebx, net_sockets
        mov     si, [edx + TCP_header.DestinationPort]
 
  .socket_loop:
        mov     ebx, [ebx + SOCKET.NextPtr]
        or      ebx, ebx
        jz      .no_socket ;respond_seg_reset
 
        cmp     [ebx + SOCKET.Domain], AF_INET4
        jne     .socket_loop
 
        cmp     [ebx + SOCKET.Protocol], IP_PROTO_TCP
        jne     .socket_loop
 
        cmp     [ebx + TCP_SOCKET.LocalPort], si
        jne     .socket_loop
 
        mov     eax, [ebx + IP_SOCKET.RemoteIP]
        cmp     eax, [edi + IPv4_header.SourceAddress]
        je      @f
        test    eax, eax
        jnz     .socket_loop
       @@:
 
        mov     ax, [ebx + TCP_SOCKET.RemotePort]
        cmp     [edx + TCP_header.SourcePort], ax
        je      .found_socket
        test    ax, ax
        jnz     .socket_loop
  .found_socket:                                        ; ebx now contains the socketpointer
        pusha
        mov     ecx, socket_mutex
        call    mutex_unlock
        popa
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: socket ptr=%x state=%u flags=%x\n", ebx, [ebx + TCP_SOCKET.t_state], [edx + TCP_header.Flags]:2
 
;----------------------------
; Check if socket isnt closed
 
        cmp     [ebx + TCP_SOCKET.t_state], TCPS_CLOSED
        je      .drop_no_socket
 
;----------------
; Lock the socket
 
        pusha
        lea     ecx, [ebx + SOCKET.mutex]
        call    mutex_lock
        popa
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: socket locked\n"
 
;---------------------------
; disable all temporary bits
 
        mov     [temp_bits], 0
 
;---------------------------------------
; unscale the window into a 32 bit value
 
        movzx   eax, [edx + TCP_header.Window]
        push    ecx
        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
        pop     ecx
 
;-----------------------------------------------------------------------------------
;
; Accept incoming connections
;
;-----------------------------------------------------------------------------------
 
        test    [ebx + SOCKET.options], SO_ACCEPTCON
        jz      .no_accept
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Accepting new connection\n"
 
; Unlock current socket
 
        pusha
        lea     ecx, [ebx + SOCKET.mutex]
        call    mutex_unlock
        popa
 
; Fork it
 
        push    ecx edx esi edi
        call    socket_fork
        pop     edi esi edx ecx
 
        test    eax, eax
        jz      .drop_no_socket
 
; Success! Use the new socket from now on (it is already locked)
 
        mov     ebx, eax
 
        mov     [temp_bits], TCP_BIT_DROPSOCKET
 
        push    [edi + IPv4_header.DestinationAddress]
        pop     [ebx + IP_SOCKET.LocalIP]
 
        push    [edx + TCP_header.DestinationPort]
        pop     [ebx + TCP_SOCKET.LocalPort]
 
        mov     [ebx + TCP_SOCKET.t_state], TCPS_LISTEN
  .no_accept:
 
 
;-------------------------------------
; Reset idle timer and keepalive timer
 
        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
;
;-----------------------------------------------------------------------------------
 
;;; FIXME: for LISTEN, options should be called after we determined route, we need it for MSS
;;;        cmp     [ebx + TCP_SOCKET.t_state], TCPS_LISTEN ; no options when in listen state
;;;        jz      .not_uni_xfer                           ; also no header prediction
 
        push    ecx
 
        mov     ecx, [dataoffset]
        cmp     ecx, sizeof.TCP_header          ; Does header contain any options?
        je      .no_options
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Segment has options\n"
 
        add     ecx, edx
        lea     esi, [edx + sizeof.TCP_header]
 
  .opt_loop:
        cmp     esi, ecx                        ; are we scanning outside of header?
        jae     .no_options
        lodsb
        cmp     al, TCP_OPT_EOL                 ; end of option list?
        je      .no_options
        cmp     al, TCP_OPT_NOP
        je      .opt_loop
        cmp     al, TCP_OPT_MAXSEG
        je      .opt_maxseg
        cmp     al, TCP_OPT_WINDOW
        je      .opt_window
        cmp     al, TCP_OPT_SACK_PERMIT
        je      .opt_sack_permit
;        cmp     al, TCP_OPT_SACK
;        je      .opt_sack
        cmp     al, TCP_OPT_TIMESTAMP
        je      .opt_timestamp
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: unknown option:%u\n", al
        jmp     .no_options                     ; If we reach here, some unknown options were received, skip them all!
 
  .opt_maxseg:
        lodsb
        cmp     al, 4
        jne     .no_options                     ; error occured, ignore all options!
 
        test    [edx + TCP_header.Flags], TH_SYN
        jz      @f
 
        xor     eax, eax
        lodsw
        rol     ax, 8
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Maxseg=%u\n", eax
        call    tcp_mss
       @@:
        jmp     .opt_loop
 
 
  .opt_window:
        lodsb
        cmp     al, 3
        jne     .no_options
 
        test    [edx + TCP_header.Flags], TH_SYN
        jz      @f
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Got window scale option\n"
        or      [ebx + TCP_SOCKET.t_flags], TF_RCVD_SCALE
 
        lodsb
        mov     [ebx + TCP_SOCKET.SND_SCALE], al
        ;;;;; TODO
 
       @@:
        jmp     .opt_loop
 
 
  .opt_sack_permit:
        lodsb
        cmp     al, 2
        jne     .no_options
 
        test    [edx + TCP_header.Flags], TH_SYN
        jz      @f
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Selective Acknowledgement permitted\n"
        or      [ebx + TCP_SOCKET.t_flags], TF_SACK_PERMIT
 
       @@:
        jmp     .opt_loop
 
 
  .opt_timestamp:
        lodsb
        cmp     al, 10                          ; length must be 10
        jne     .no_options
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Got timestamp option\n"
 
        test    [edx + TCP_header.Flags], TH_SYN
        jz      @f
        or      [ebx + TCP_SOCKET.t_flags], TF_RCVD_TSTMP
       @@:
 
        lodsd
        bswap   eax
        mov     [ebx + TCP_SOCKET.ts_val], eax
        lodsd                                   ; timestamp echo reply
        mov     [ebx + TCP_SOCKET.ts_ecr], eax
        or      [temp_bits], TCP_BIT_TIMESTAMP
 
        ; Since we have a timestamp, lets do the paws test right away!
 
        test    [edx + TCP_header.Flags], TH_RST
        jnz     .no_paws
 
        mov     eax, [ebx + TCP_SOCKET.ts_recent]
        test    eax, eax
        jz      .no_paws
        cmp     eax, [ebx + TCP_SOCKET.ts_val]
        jbe     .no_paws
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: PAWS: detected an old segment\n"
 
        mov     eax, [timestamp]
        sub     eax, [ebx + TCP_SOCKET.ts_recent_age]
 
        pop     ecx
        cmp     eax, TCP_PAWS_IDLE
        jle     .paws_drop
        push    ecx
        mov     [ebx + TCP_SOCKET.ts_recent], 0         ; timestamp was invalid, fix it.
  .no_paws:
        jmp     .opt_loop
 
  .paws_drop:
        inc     [TCPS_rcvduppack]
        add     [TCPS_rcvdupbyte], ecx
        inc     [TCPS_pawsdrop]
        jmp     .drop_after_ack
 
  .no_options:
 
        pop     ecx
 
;-----------------------------------------------------------------------------------
;
; Header prediction
;
;-----------------------------------------------------------------------------------
 
; According to Van Jacobson, there are two common cases for an uni-directional data transfer.
;
; General rule: the packets has no control flags, is in-sequence,
;   window width didnt change and we're not retransmitting.
;
; Second rules:
;  -  If the length is 0 and the ACK moved forward, we're the sender side of the transfer.
;      In this case we'll free the ACK'ed data and notify higher levels that we have free space in buffer
;
;  -  If the length is not 0 and the ACK didn't move, we're the receiver side of the transfer.
;      If the packets are in order (data queue is empty), add the data to the socket buffer and request a delayed ACK
 
        cmp     [ebx + TCP_SOCKET.t_state], TCPS_ESTABLISHED
        jnz     .not_uni_xfer
 
        test    [edx + TCP_header.Flags], TH_SYN + TH_FIN + TH_RST + TH_URG
        jnz     .not_uni_xfer
 
        test    [edx + TCP_header.Flags], TH_ACK
        jz      .not_uni_xfer
 
        mov     eax, [edx + TCP_header.SequenceNumber]
        cmp     eax, [ebx + TCP_SOCKET.RCV_NXT]
        jne     .not_uni_xfer
 
        mov     eax, dword[edx + TCP_header.Window]
        cmp     eax, [ebx + TCP_SOCKET.SND_WND]
        jne     .not_uni_xfer
 
        mov     eax, [ebx + TCP_SOCKET.SND_NXT]
        cmp     eax, [ebx + TCP_SOCKET.SND_MAX]
        jne     .not_uni_xfer
 
;---------------------------------------
; 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.
 
        test    ecx, ecx
        jnz     .not_sender
 
; - 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.
 
        mov     eax, [ebx + TCP_SOCKET.SND_CWND]
        cmp     eax, [ebx + TCP_SOCKET.SND_WND]
        jb      .not_uni_xfer
 
; - 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]
        ja      .not_uni_xfer
 
; - 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"
 
;---------------------------------
; Packet is a pure ACK, process it
 
        inc     [TCPS_predack]
 
        inc     [TCPS_rcvackpack]
        add     [TCPS_rcvackbyte], eax
 
; Delete acknowledged bytes from send buffer
 
        pusha
        mov     ecx, eax
        lea     eax, [ebx + STREAM_SOCKET.snd]
        call    socket_ring_free
        popa
 
; Update RTT estimators
 
        test    [temp_bits], TCP_BIT_TIMESTAMP
        jz      .no_timestamp_rtt
        mov     eax, [timestamp]
        sub     eax, [ebx + TCP_SOCKET.ts_ecr]
        inc     eax
        call    tcp_xmit_timer
        jmp     .rtt_done
  .no_timestamp_rtt:
 
        cmp     [ebx + TCP_SOCKET.t_rtt], 0
        je      .rtt_done
        mov     eax, [edx + TCP_header.AckNumber]
        cmp     eax, [ebx + TCP_SOCKET.t_rtseq]
        jbe     .rtt_done
        mov     eax, [ebx + TCP_SOCKET.t_rtt]
        call    tcp_xmit_timer
  .rtt_done:
 
; update window pointers
 
        mov     eax, [edx + TCP_header.AckNumber]
        mov     [ebx + TCP_SOCKET.SND_UNA], eax
 
; Stop retransmit timer
 
        and     [ebx + TCP_SOCKET.timer_flags], not timer_flag_retransmission
 
; Unlock the socket
 
        pusha
        lea     ecx, [ebx + SOCKET.mutex]
        call    mutex_unlock
        popa
 
; Awaken waiting processes
 
        mov     eax, ebx
        call    socket_notify
 
; Generate more output
 
        call    tcp_output
 
        jmp     .drop_no_socket
 
;-------------------------------------------------
; maybe we are the receiver in the uni-xfer then..
 
  .not_sender:
 
; - 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.
 
        mov     eax, [edx + TCP_header.AckNumber]
        cmp     eax, [ebx + TCP_SOCKET.SND_UNA]
        jne     .not_uni_xfer
 
; - The reassembly list of out-of-order segments for the connection is empty.
 
        cmp     [ebx + TCP_SOCKET.seg_next], 0
        jne     .not_uni_xfer
 
; Complete processing of received data
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Header prediction: we are receiving %u bytes\n", ecx
 
        mov     esi, [dataoffset]
        add     esi, edx
        lea     eax, [ebx + STREAM_SOCKET.rcv]
        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
 
        mov     eax, ebx
        call    socket_notify
 
        or      [ebx + TCP_SOCKET.t_flags], TF_DELACK   ; Set delayed ack flag
 
        jmp     .drop
 
 
;-----------------------------------------------------------------------------------
;
; TCP segment processing, the slow way
;
;-----------------------------------------------------------------------------------
 
  .not_uni_xfer:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Header prediction failed\n"
 
; Calculate receive window size
 
        push    edx
        mov     eax, SOCKET_BUFFER_SIZE
        sub     eax, [ebx + STREAM_SOCKET.rcv.size]
        DEBUGF  DEBUG_NETWORK_VERBOSE, "Space in receive buffer=%d\n", eax
        mov     edx, [ebx + TCP_SOCKET.RCV_ADV]
        sub     edx, [ebx + TCP_SOCKET.RCV_NXT]
        DEBUGF  DEBUG_NETWORK_VERBOSE, "Current advertised window=%d\n", edx
        cmp     eax, edx
        jg      @f
        mov     eax, edx
       @@:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "Receive window size=%d\n", eax
        mov     [ebx + TCP_SOCKET.RCV_WND], eax
        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      .state_listen
 
        cmp     [ebx + TCP_SOCKET.t_state], TCPS_SYN_SENT
        je      .state_syn_sent
 
;-----------------------------------------------------------------------------------
;
; Trim any data not in window
;
;-----------------------------------------------------------------------------------
 
;-------------------------------------------------
; Check for duplicate data at beginning of segment
 
; Calculate number of bytes we need to drop
 
        mov     eax, [ebx + TCP_SOCKET.RCV_NXT]
        sub     eax, [edx + TCP_header.SequenceNumber]
        jle     .no_duplicate
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: %u bytes duplicate data!\n", eax
 
; Check for duplicate SYN
 
        test    [edx + TCP_header.Flags], TH_SYN
        jz      .no_dup_syn
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: got duplicate syn\n"
 
        and     [edx + TCP_header.Flags], not (TH_SYN)
        inc     [edx + TCP_header.SequenceNumber]
 
        cmp     [edx + TCP_header.UrgentPointer], 1
        jbe     @f
        dec     [edx + TCP_header.UrgentPointer]
        jmp     .dup_syn
       @@:
        and     [edx + TCP_header.Flags], not (TH_URG)
  .dup_syn:
        dec     eax
  .no_dup_syn:
 
;-----------------------------------
; Check for entire duplicate segment
 
        cmp     eax, ecx                ; eax holds number of bytes to drop, ecx is data size
        jb      .no_complete_dup
        jnz     @f
        test    [edx + TCP_header.Flags], TH_FIN
        jnz     .no_complete_dup
       @@:
 
; 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
 
        and     [edx + TCP_header.Flags], not TH_FIN
 
; send an ACK to resynchronize and drop any data.
; But keep on processing for RST or ACK
 
        or      [ebx + TCP_SOCKET.t_flags], TF_ACKNOW
        mov     eax, ecx
 
        inc     [TCPS_rcvduppack]
        add     [TCPS_rcvdupbyte], eax
        jmp     .dup_processed
  .no_complete_dup:
        inc     [TCPS_rcvpartduppack]
        add     [TCPS_rcvpartdupbyte], eax
  .dup_processed:
 
;-----------------------------------------------
; Remove duplicate data and update urgent offset
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: trimming duplicate data\n"
 
; Trim data from left side of window
 
        add     [dataoffset], eax
        add     [edx + TCP_header.SequenceNumber], 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
       @@:
  .no_duplicate:
 
;--------------------------------------------------
; Handle data that arrives after process terminates
 
        cmp     [ebx + SOCKET.PID], 0                   ;;; TODO: use socket flags instead??
        jne     .not_terminated
        cmp     [ebx + TCP_SOCKET.t_state], TCPS_CLOSE_WAIT
        jbe     .not_terminated
        test    ecx, ecx
        jz      .not_terminated
 
        mov     eax, ebx
        call    tcp_close
        inc     [TCPS_rcvafterclose]
        jmp     .respond_seg_reset
  .not_terminated:
 
;----------------------------------------
; Remove data beyond right edge of window
 
        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
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "%d bytes beyond right edge of window\n", eax
 
        inc     [TCPS_rcvpackafterwin]
 
        cmp     eax, ecx
        jl      .dont_drop_all
 
        add     [TCPS_rcvbyteafterwin], ecx
 
;----------------------------------------------------------------------------------------------------
; 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
        cmp     [ebx + TCP_SOCKET.t_state], TCPS_TIME_WAIT
        jne     .no_new_request
;        mov     edx, [ebx + TCP_SOCKET.RCV_NXT]
;        cmp     edx, [edx + TCP_header.SequenceNumber]
;        add     edx, 64000      ; TCP_ISSINCR   FIXME
        mov     eax, ebx
        call    tcp_close
        jmp     .findpcb        ; FIXME: skip code for unscaling window, ...
  .no_new_request:
 
; If window is closed, we can only take segments at window edge, and have to drop data and PUSH from
; incoming segments. Continue processing, but remember to ACK. Otherwise drop segment and ACK
 
        cmp     [ebx + TCP_SOCKET.RCV_WND], 0
        jne     .drop_after_ack
        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
        inc     [TCPS_rcvwinprobe]
  .dont_drop_all:
        add     [TCPS_rcvbyteafterwin], eax
        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
        and     [edx + TCP_header.Flags], not (TH_PUSH or TH_FIN)
  .no_excess_data:
 
;-----------------------------------------------------------------------------------
;
; Record 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    [edx + TCP_header.Flags], TH_SYN or TH_FIN      ; SYN and FIN occupy one byte
        jz      @f
        dec     eax
       @@:
        sub     eax, ecx
        jae     .no_timestamp
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "Recording timestamp\n"
 
        mov     eax, [timestamp]
        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
;
;-----------------------------------------------------------------------------------
 
        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]
        shl     eax, 2
        jmp     dword [eax + .rst_sw_list]
 
;-----------------------------------------------------------------------------------
  .rst_sw_list:
        dd      .no_rst         ; TCPS_CLOSED
        dd      .no_rst         ; TCPS_LISTEN
        dd      .no_rst         ; TCPS_SYN_SENT
        dd      .econnrefused   ; TCPS_SYN_RECEIVED
        dd      .econnreset     ; TCPS_ESTABLISHED
        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_TIME_WAIT
 
;-----------------------------------------------------------------------------------
  .econnrefused:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Connection refused\n"
        mov     [ebx + SOCKET.errorcode], ECONNREFUSED
        jmp     .close
 
;-----------------------------------------------------------------------------------
  .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"
        mov     [ebx + TCP_SOCKET.t_state], TCPS_CLOSED
        inc     [TCPS_drops]
 
 
 
 
        jmp     .drop
 
;-----------------------------------------------------------------------------------
  .rst_close:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Closing with reset\n"
 
 
 
        jmp     .unlock_and_close
 
;-----------------------------------------------------------------------------------
  .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
 
        mov     eax, ebx
        mov     ebx, ECONNRESET
        call    tcp_drop
        jmp     .drop_with_reset
  .not_syn_full:
 
; If ACK bit is off, we drop the segment and return
 
        test    [edx + TCP_header.Flags], TH_ACK
        jz      .drop
 
;----------------------------------------------------------------------------------
;
; ACK processing for SYN_RECEIVED state
;
;----------------------------------------------------------------------------------
 
        cmp     [ebx + TCP_SOCKET.t_state], TCPS_SYN_RECEIVED
        jb      .ack_processed                                  ; states: closed, listen, syn_sent
        ja      .no_syn_rcv                                     ; established, fin_wait_1, fin_wait_2, close_wait, closing, last_ack, time_wait
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: state=syn_received\n"
 
        mov     eax, [edx + TCP_header.AckNumber]
        cmp     [ebx + TCP_SOCKET.SND_UNA], eax
        ja      .drop_with_reset
        cmp     eax, [ebx + TCP_SOCKET.SND_MAX]
        ja      .drop_with_reset
 
        inc     [TCPS_connects]
 
        mov     eax, ebx
        call    socket_is_connected
        mov     [ebx + TCP_SOCKET.t_state], TCPS_ESTABLISHED
 
; Do window scaling?
 
        test    [ebx + TCP_SOCKET.t_flags], TF_RCVD_SCALE
        jz      @f
        test    [ebx + TCP_SOCKET.t_flags], TF_REQ_SCALE
        jz      @f
 
        push    word[ebx + TCP_SOCKET.requested_s_scale]        ; Set send and receive scale factors to the received values
        pop     word[ebx + TCP_SOCKET.SND_SCALE]
       @@:
 
        call    tcp_reassemble
 
        mov     eax, [edx + TCP_header.SequenceNumber]
        dec     eax
        mov     [ebx + TCP_SOCKET.SND_WL1], eax
  .no_syn_rcv:
 
;-----------------------------------------------------------------------------------
;
; ACK processing for SYN_RECEIVED state and higher
;
;-----------------------------------------------------------------------------------
 
;-------------------------
; Check for duplicate ACKs
 
        mov     eax, [edx + TCP_header.AckNumber]
        cmp     eax, [ebx + TCP_SOCKET.SND_UNA]
        ja      .dup_ack_complete
 
        test    ecx, ecx
        jnz     .reset_dupacks
 
        mov     eax, dword[edx + TCP_header.Window]
        cmp     eax, [ebx + TCP_SOCKET.SND_WND]
        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.
 
        test    [ebx + TCP_SOCKET.timer_flags], timer_flag_retransmission
        jz      .reset_dupacks
 
        mov     eax, [edx + TCP_header.AckNumber]
        cmp     eax, [ebx + TCP_SOCKET.SND_UNA]
        jne     .reset_dupacks
 
; Increment dupplicat ACK counter
; If it reaches the threshold, re-transmit the missing segment
 
        inc     [ebx + TCP_SOCKET.t_dupacks]
        cmp     [ebx + TCP_SOCKET.t_dupacks], TCP_re_xmit_thresh
        jb      .dup_ack_complete
        ja      .another_lost
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Re-transmitting lost segment\n"
 
        push    [ebx + TCP_SOCKET.SND_NXT]              ; >>>>
 
        mov     eax, [ebx + TCP_SOCKET.SND_WND]
        cmp     eax, [ebx + TCP_SOCKET.SND_CWND]
        jbe     @f
        mov     eax, [ebx + TCP_SOCKET.SND_CWND]
  @@:
        shr     eax, 1
        push    edx
        xor     edx, edx
        div     [ebx + TCP_SOCKET.t_maxseg]
        cmp     eax, 2
        ja      @f
        xor     eax, eax
        mov     al, 2
       @@:
        mul     [ebx + TCP_SOCKET.t_maxseg]
        pop     edx
        mov     [ebx + TCP_SOCKET.SND_SSTHRESH], eax
 
        and     [ebx + TCP_SOCKET.timer_flags], not timer_flag_retransmission   ; turn off retransmission timer
        mov     [ebx + TCP_SOCKET.t_rtt], 0
        mov     eax, [edx + TCP_header.AckNumber]
        mov     [ebx + TCP_SOCKET.SND_NXT], eax
        mov     eax, [ebx + TCP_SOCKET.t_maxseg]
        mov     [ebx + TCP_SOCKET.SND_CWND], eax
 
; Unlock the socket
 
        push    ebx
        lea     ecx, [ebx + SOCKET.mutex]
        call    mutex_unlock
 
; retransmit missing segment
 
        mov     eax, [esp]
        call    tcp_output
 
; Lock the socket again
 
        mov     ecx, [esp]
        add     ecx, SOCKET.mutex
        call    mutex_lock
        pop     ebx
 
; Continue processing
 
        xor     edx, edx
        mov     eax, [ebx + TCP_SOCKET.t_maxseg]
        mul     [ebx + TCP_SOCKET.t_dupacks]
        add     eax, [ebx + TCP_SOCKET.SND_SSTHRESH]
        mov     [ebx + TCP_SOCKET.SND_CWND], eax
 
        pop     eax                                     ; <<<<
        cmp     eax, [ebx + TCP_SOCKET.SND_NXT]
        jb      @f
        mov     [ebx + TCP_SOCKET.SND_NXT], eax
       @@:
        jmp     .drop
 
  .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
 
; Unlock the socket
 
        push    ebx
        lea     ecx, [ebx + SOCKET.mutex]
        call    mutex_unlock
 
; retransmit missing segment, again
 
        mov     eax, [esp]
        call    tcp_output
 
; Lock the socket again
 
        mov     ecx, [esp]
        add     ecx, SOCKET.mutex
        call    mutex_lock
        pop     ebx
 
; And drop the incoming segment
 
        jmp     .drop
 
  .reset_dupacks:               ; We got a new ACK, reset duplicate ACK counter
        mov     [ebx + TCP_SOCKET.t_dupacks], 0
        jmp     .ack_processed
 
  .dup_ack_complete:
 
;-------------------------------------------------
; If the congestion window was inflated to account
; for the other side's cached packets, retract it
 
        mov     eax, [ebx + TCP_SOCKET.SND_SSTHRESH]
        cmp     eax, [ebx + TCP_SOCKET.SND_CWND]
        ja      @f
        cmp     [ebx + TCP_SOCKET.t_dupacks], TCP_re_xmit_thresh
        jbe     @f
        mov     [ebx + TCP_SOCKET.SND_CWND], eax
       @@:
 
        mov     [ebx + TCP_SOCKET.t_dupacks], 0
 
        mov     eax, [edx + TCP_header.AckNumber]
        cmp     eax, [ebx + TCP_SOCKET.SND_MAX]
        jbe     @f
        inc     [TCPS_rcvacktoomuch]
        jmp     .drop_after_ack
       @@:
 
        mov     edi, [edx + TCP_header.AckNumber]
        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
;
;-----------------------------------------------------------------------------------
 
; If we have a timestamp, update smoothed RTT
 
        test    [temp_bits], TCP_BIT_TIMESTAMP
        jz      .timestamp_not_present
        mov     eax, [timestamp]
        sub     eax, [ebx + TCP_SOCKET.ts_ecr]
        inc     eax
        call    tcp_xmit_timer
        jmp     .rtt_done_
 
; If no timestamp but transmit timer is running and timed sequence number was acked,
; update smoothed RTT. Since we now have an RTT measurement, cancel the timer backoff
; (Phil Karn's retransmit algo)
; Recompute the initial retransmit timer
 
  .timestamp_not_present:
        mov     eax, [edx + TCP_header.AckNumber]
        cmp     eax, [ebx + TCP_SOCKET.t_rtseq]
        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)
; If there is more data to be acked, restart retransmit timer, using current (possible backed-off) value.
 
        mov     eax, [ebx + TCP_SOCKET.SND_MAX]
        cmp     eax, [edx + TCP_header.AckNumber]
        jne     .more_data
        and     [ebx + TCP_SOCKET.timer_flags], not timer_flag_retransmission
        or      [temp_bits], TCP_BIT_NEEDOUTPUT
        jmp     .no_restart
  .more_data:
        test    [ebx + TCP_SOCKET.timer_flags], timer_flag_persist
        jnz     .no_restart
 
        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.
; Otherwise, open lineary
 
        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             ; t_maxseg*t_maxseg
        div     esi             ; t_maxseg*t_maxseg/snd_cwnd
        pop     edx             ; t_maxseg
        shr     edx, 3          ; t_maxseg/8
        add     eax, edx        ; t_maxseg*t_maxseg/snd_cwnd + t_maxseg/8
        pop     edx
       @@:
        add     esi, eax
 
        push    ecx
        mov     cl, [ebx + TCP_SOCKET.SND_SCALE]
        mov     eax, TCP_max_win
        shl     eax, cl
        pop     ecx
 
        cmp     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
; 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
 
; Drop all data in output buffer
 
        push    ecx edx ebx
        mov     ecx, [ebx + STREAM_SOCKET.snd.size]
        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"
        or      [temp_bits], TCP_BIT_FIN_IS_ACKED
        jmp     .ack_complete
  .no_fin_ack:
 
; Drop acknowledged data
 
        push    ecx edx ebx
        mov     ecx, edi
        lea     eax, [ebx + STREAM_SOCKET.snd]
        call    socket_ring_free
        pop     ebx
        sub     [ebx + TCP_SOCKET.SND_WND], ecx
        pop     edx ecx
  .ack_complete:
 
;-----------------------------------------------------------------------------------
;
; Wake up process waiting on send buffer
;
;-----------------------------------------------------------------------------------
 
        mov     eax, ebx
        call    socket_notify
 
; Update TCPS
 
        mov     eax, [edx + TCP_header.AckNumber]
        mov     [ebx + TCP_SOCKET.SND_UNA], eax
        cmp     eax, [ebx + TCP_SOCKET.SND_NXT]
        jb      @f
        mov     [ebx + TCP_SOCKET.SND_NXT], eax
       @@:
 
;-----------------------------------------------------------------------------------
;
; State specific ACK handeling
;
;-----------------------------------------------------------------------------------
 
        mov     eax, [ebx + TCP_SOCKET.t_state]
        jmp     dword[.ack_sw_list+eax*4]
 
  .ack_sw_list:
        dd      .ack_processed  ; TCPS_CLOSED
        dd      .ack_processed  ; TCPS_LISTEN
        dd      .ack_processed  ; TCPS_SYN_SENT
        dd      .ack_processed  ; TCPS_SYN_RECEIVED
        dd      .ack_processed  ; TCPS_ESTABLISHED
        dd      .ack_processed  ; TCPS_CLOSE_WAIT
        dd      .ack_fw1        ; TCPS_FIN_WAIT_1
        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
 
        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,
; 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
        jmp     .ack_processed
 
;-----------------------------------------------------------------------------------
  .ack_c:
; Enter the TIME_WAIT state if our FIN is acked in CLOSED state.
 
        test    [temp_bits], TCP_BIT_FIN_IS_ACKED
        jz      .ack_processed
 
        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
        mov     eax, ebx
        call    socket_is_disconnected
        jmp     .ack_processed
 
;-----------------------------------------------------------------------------------
  .ack_la:
; 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.
 
        test    [temp_bits], TCP_BIT_FIN_IS_ACKED
        jz      .ack_processed
 
  .unlock_and_close:
        push    ebx
        lea     ecx, [ebx + SOCKET.mutex]
        call    mutex_unlock
        pop     eax
 
        call    tcp_close
        jmp     .drop_no_socket
 
;-----------------------------------------------------------------------------------
  .ack_tw:
; In TIME_WAIT state the only thing that should arrive is a retransmission of the remote FIN.
; Acknowledge it and restart the FINACK timer
 
        mov     [ebx + TCP_SOCKET.timer_timed_wait], 2*TCP_time_MSL
        or      [ebx + TCP_SOCKET.timer_flags], timer_flag_2msl
        jmp     .drop_after_ack
 
;-----------------------------------------------------------------------------------
;
; Initiation of Passive Open?
;
;-----------------------------------------------------------------------------------
 
  .state_listen:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: state=listen\n"
 
        test    [edx + TCP_header.Flags], TH_RST
        jnz     .drop
 
        test    [edx + TCP_header.Flags], TH_ACK
        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
 
;-------------------------------------------
; 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]
 
        mov     eax, [TCP_sequence_num]
        add     [TCP_sequence_num], TCP_ISSINCR / 2
        mov     [ebx + TCP_SOCKET.ISS], eax
        mov     [ebx + TCP_SOCKET.SND_NXT], eax
 
        tcp_sendseqinit ebx
        tcp_rcvseqinit ebx
 
        mov     [ebx + TCP_SOCKET.t_state], TCPS_SYN_RECEIVED
        or      [ebx + TCP_SOCKET.t_flags], TF_ACKNOW
        mov     [ebx + TCP_SOCKET.timer_keepalive], TCP_time_keep_interval  ;;;; macro
        or      [ebx + TCP_SOCKET.timer_flags], timer_flag_keepalive
 
        lea     eax, [ebx + STREAM_SOCKET.snd]
        call    socket_ring_create
        test    eax, eax
        jz      .drop
 
        lea     eax, [ebx + STREAM_SOCKET.rcv]
        call    socket_ring_create
        test    eax, eax
        jz      .drop
 
        and     [temp_bits], not TCP_BIT_DROPSOCKET
 
        pusha
        mov     eax, ebx
        call    socket_notify
        popa
 
        jmp     .trim
 
;-----------------------------------------------------------------------------------
;
; Completion of active open?
;
;-----------------------------------------------------------------------------------
 
  .state_syn_sent:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: state=syn_sent\n"
 
        test    [edx + TCP_header.Flags], TH_ACK
        jz      @f
 
        mov     eax, [edx + TCP_header.AckNumber]
        cmp     eax, [ebx + TCP_SOCKET.ISS]
        jbe     .drop_with_reset
 
        cmp     eax, [ebx + TCP_SOCKET.SND_MAX]
        ja      .drop_with_reset
       @@:
 
        test    [edx + TCP_header.Flags], TH_RST
        jz      @f
 
        test    [edx + TCP_header.Flags], TH_ACK
        jz      .drop
 
        mov     eax, ebx
        mov     ebx, ECONNREFUSED
        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_ACK
        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_NXT], eax
 
        and     [ebx + TCP_SOCKET.timer_flags], not timer_flag_retransmission   ; disable retransmission timer
       @@:
 
        push    [edx + TCP_header.SequenceNumber]
        pop     [ebx + TCP_SOCKET.IRS]
 
        tcp_rcvseqinit ebx
 
        or      [ebx + TCP_SOCKET.t_flags], TF_ACKNOW
 
        mov     eax, [ebx + TCP_SOCKET.SND_UNA]
        cmp     eax, [ebx + TCP_SOCKET.ISS]
        jbe     .simultaneous_open
 
        test    [edx + TCP_header.Flags], TH_ACK
        jz      .simultaneous_open
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: active open\n"
 
        inc     [TCPS_connects]
 
; set socket state to connected
 
        push    eax
        mov     eax, ebx
        call    socket_is_connected
        pop     eax
        mov     [ebx + TCP_SOCKET.t_state], TCPS_ESTABLISHED
 
; Do window scaling on this connection ?
 
        mov     eax, [ebx + TCP_SOCKET.t_flags]
        and     eax, TF_REQ_SCALE or TF_RCVD_SCALE
        cmp     eax, TF_REQ_SCALE or TF_RCVD_SCALE
        jne     .no_scaling
 
        mov     ax, word[ebx + TCP_SOCKET.requested_s_scale]
        mov     word[ebx + TCP_SOCKET.SND_SCALE], ax
  .no_scaling:
 
;;; TODO: reassemble packets queue
 
; If we didnt have time to re-transmit the SYN,
; 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
 
;-----------------------------------------------------------------------------------
;
; Simultaneous open (We have received a SYN but no ACK)
;
;-----------------------------------------------------------------------------------
 
  .simultaneous_open:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: simultaneous open\n"
        mov     [ebx + TCP_SOCKET.t_state], TCPS_SYN_RECEIVED
 
;-----------------------------------------------------------------------------------
;
; Common processing for receipt of SYN
;
;-----------------------------------------------------------------------------------
 
  .trim:
; Advance sequence number to correspond to first data byte.
; If data, trim to stay within window, dropping FIN if necessary
 
        inc     [edx + TCP_header.SequenceNumber]
 
; Drop any received data that doesnt fit in the receive window.
 
        cmp     ecx, [ebx + TCP_SOCKET.RCV_WND]
        jbe     .dont_trim
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: received data does not fit in window, trimming %u bytes\n", eax
        inc     [TCPS_rcvpackafterwin]
        sub     ecx, [ebx + TCP_SOCKET.RCV_WND]
        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     [ebx + TCP_SOCKET.RCV_UP], eax
        dec     eax
        mov     [ebx + TCP_SOCKET.SND_WL1], eax
 
;-----------------------------------------------------------------------------------
;
; Update window information (step 6 in RFC793)
;
;-----------------------------------------------------------------------------------
 
  .ack_processed:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: ACK processed\n"
 
; dont look at window if no ACK
 
        test    [edx + TCP_header.Flags], TH_ACK
        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
 
; No new data but a new ACK ?
 
        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
 
        mov     eax, dword[edx + TCP_header.Window]
        cmp     eax, [ebx + TCP_SOCKET.SND_WND]
        jbe     .no_window_update
 
 
; Keep track of pure window updates
  .update_window:
        test    ecx, ecx
        jnz     @f
        mov     eax, [ebx + TCP_SOCKET.SND_WL2]
        cmp     eax, [edx + TCP_header.AckNumber]
        jne     @f
        mov     eax, dword[edx + TCP_header.Window]
        cmp     eax, [ebx + TCP_SOCKET.SND_WND]
        jbe     @f
        inc     [TCPS_rcvwinupd]
       @@:
 
        mov     eax, dword[edx + TCP_header.Window]
        mov     [ebx + TCP_SOCKET.SND_WND], eax
        cmp     eax, [ebx + TCP_SOCKET.max_sndwnd]
        jbe     @f
        mov     [ebx + TCP_SOCKET.max_sndwnd], eax
       @@:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Updating window to %u\n", eax
 
        push    [edx + TCP_header.SequenceNumber]
        pop     [ebx + TCP_SOCKET.SND_WL1]
 
        push    [edx + TCP_header.AckNumber]
        pop     [ebx + TCP_SOCKET.SND_WL2]
 
        or      [temp_bits], TCP_BIT_NEEDOUTPUT
  .no_window_update:
 
;-----------------------------------------------------------------------------------
;
; Process URG flag
;
;-----------------------------------------------------------------------------------
 
        test    [edx + TCP_header.Flags], TH_URG
        jz      .not_urgent
 
        cmp     [edx + TCP_header.UrgentPointer], 0
        jz      .not_urgent
 
        cmp     [ebx + TCP_SOCKET.t_state], TCPS_TIME_WAIT
        je      .not_urgent
 
; Ignore bogus urgent offsets
 
        movzx   eax, [edx + TCP_header.UrgentPointer]
        add     eax, [ebx + STREAM_SOCKET.rcv.size]
        cmp     eax, SOCKET_BUFFER_SIZE
        jbe     .not_urgent
 
        mov     [edx + TCP_header.UrgentPointer], 0
        and     [edx + TCP_header.Flags], not (TH_URG)
        jmp     .do_data
 
  .not_urgent:
 
; processing of received urgent pointer
 
        ;;; TODO (1051-1093)
 
;-----------------------------------------------------------------------------------
;
; Process the data
;
;-----------------------------------------------------------------------------------
 
  .do_data:
        cmp     [ebx + TCP_SOCKET.t_state], TCPS_TIME_WAIT
        jae     .final_processing
 
        test    [edx + TCP_header.Flags], TH_FIN
        jnz     @f
 
        test    ecx, ecx
        jz      .final_processing
       @@:
 
; The segment is in order?
 
        mov     eax, [edx + TCP_header.SequenceNumber]
        cmp     eax, [ebx + TCP_SOCKET.RCV_NXT]
        jne     .out_of_order
 
; The reassembly queue is empty?
 
        cmp     [ebx + TCP_SOCKET.seg_next], 0
        jne     .out_of_order
 
; The connection is established?
 
        cmp     [ebx + TCP_SOCKET.t_state], TCPS_ESTABLISHED
        jne     .out_of_order
 
; Ok, lets do this..  Set delayed ACK flag and copy data into socket buffer
 
        or      [ebx + TCP_SOCKET.t_flags], TF_DELACK
 
        pusha
        mov     esi, [dataoffset]
        add     esi, edx
        lea     eax, [ebx + STREAM_SOCKET.rcv]
        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
 
        mov     eax, ebx
        call    socket_notify
 
        jmp     .data_done
 
  .out_of_order:
        DEBUGF  DEBUG_NETWORK_VERBOSE,  "TCP data is out of order!\nSequencenumber is %u, we expected %u.\n", \
        [edx + TCP_header.SequenceNumber], [ebx + TCP_SOCKET.RCV_NXT]
 
; Uh-oh, some data is out of order, lets call TCP reassemble for help
 
        call    tcp_reassemble
 
; 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.
 
        or      [ebx + TCP_SOCKET.t_flags], TF_ACKNOW
  .data_done:
 
;-----------------------------------------------------------------------------------
;
; Process FIN
;
;-----------------------------------------------------------------------------------
 
        test    [edx + TCP_header.Flags], TH_FIN
        jz      .final_processing
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Processing FIN\n"
 
        cmp     [ebx + TCP_SOCKET.t_state], TCPS_TIME_WAIT
        jae     .not_first_fin
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: First FIN for this connection\n"
 
        mov     eax, ebx
        call    socket_cant_recv_more
 
        or      [ebx + TCP_SOCKET.t_flags], TF_ACKNOW
        inc     [ebx + TCP_SOCKET.RCV_NXT]
 
  .not_first_fin:
        mov     eax, [ebx + TCP_SOCKET.t_state]
        jmp     dword[.fin_sw_list+eax*4]
 
  .fin_sw_list:
        dd      .final_processing       ; TCPS_CLOSED
        dd      .final_processing       ; TCPS_LISTEN
        dd      .final_processing       ; TCPS_SYN_SENT
        dd      .fin_syn_est            ; TCPS_SYN_RECEIVED
        dd      .fin_syn_est            ; TCPS_ESTABLISHED
        dd      .final_processing       ; TCPS_CLOSE_WAIT
        dd      .fin_wait1              ; TCPS_FIN_WAIT_1
        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
 
        mov     [ebx + TCP_SOCKET.t_state], TCPS_CLOSE_WAIT
        jmp     .final_processing
 
;-----------------------------------------------------------------------------------
  .fin_wait1:
; From FIN_WAIT_1 state, enter CLOSING state (our FIN has not been ACKed)
 
        mov     [ebx + TCP_SOCKET.t_state], TCPS_CLOSING
        jmp     .final_processing
 
;-----------------------------------------------------------------------------------
  .fin_wait2:
; From FIN_WAIT_2 state, enter TIME_WAIT state and start the timer
 
        mov     [ebx + TCP_SOCKET.t_state], TCPS_TIME_WAIT
        mov     eax, ebx
        call    tcp_cancel_timers
        call    socket_is_disconnected
 
;-----------------------------------------------------------------------------------
  .fin_timed:
; (re)start the 2 MSL timer
        mov     [ebx + TCP_SOCKET.timer_timed_wait], 2 * TCP_time_MSL
        or      [ebx + TCP_SOCKET.timer_flags], timer_flag_wait
 
;-----------------------------------------------------------------------------------
;
; Finally, drop the segment
;
;-----------------------------------------------------------------------------------
 
  .final_processing:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Final processing\n"
 
        push    ebx
        lea     ecx, [ebx + SOCKET.mutex]
        call    mutex_unlock
        pop     eax
 
        test    [temp_bits], TCP_BIT_NEEDOUTPUT
        jnz     .need_output
 
        test    [eax + TCP_SOCKET.t_flags], TF_ACKNOW
        jz      .done
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: ACK now!\n"
 
  .need_output:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: need output\n"
        call    tcp_output
 
  .done:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: dumping\n"
 
        call    net_buff_free
        jmp     .loop
 
;-----------------------------------------------------------------------------------
;
; Drop segment, reply with an RST segment when needed
;
;-----------------------------------------------------------------------------------
 
;-----------------------------------------------------------------------------------
  .drop_after_ack:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Drop after ACK\n"
 
        push    edx ebx
        lea     ecx, [ebx + SOCKET.mutex]
        call    mutex_unlock
        pop     eax edx
 
        test    [edx + TCP_header.Flags], TH_RST
        jnz     .done
 
        or      [eax + TCP_SOCKET.t_flags], TF_ACKNOW
        jmp     .need_output
 
;-----------------------------------------------------------------------------------
  .drop_with_reset:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Drop with reset\n"
 
        push    ebx edx
        lea     ecx, [ebx + SOCKET.mutex]
        call    mutex_unlock
        pop     edx ebx
 
        test    [edx + TCP_header.Flags], TH_RST
        jnz     .done
 
; TODO: if its a multicast/broadcast, also drop
 
        test    [edx + TCP_header.Flags], TH_ACK
        jnz     .respond_ack
 
        test    [edx + TCP_header.Flags], TH_SYN
        jnz     .respond_syn
        jmp     .done
 
  .respond_ack:
        push    ebx
        mov     cl, TH_RST
        call    tcp_respond
        pop     ebx
        jmp     .destroy_new_socket
 
  .respond_syn:
        push    ebx
        mov     cl, TH_RST + TH_ACK
        call    tcp_respond
        pop     ebx
        jmp     .destroy_new_socket
 
;-----------------------------------------
; The connection has no associated socket
 
  .no_socket:
        pusha
        mov     ecx, socket_mutex
        call    mutex_unlock
        popa
 
  .respond_seg_reset:
        test    [edx + TCP_header.Flags], TH_RST
        jnz     .drop_no_socket
 
; TODO: if its a multicast/broadcast, also drop
 
        test    [edx + TCP_header.Flags], TH_ACK
        jnz     .respond_seg_ack
 
        test    [edx + TCP_header.Flags], TH_SYN
        jnz     .respond_seg_syn
 
        jmp     .drop_no_socket
 
  .respond_seg_ack:
        mov     cl, TH_RST
        xor     ebx, ebx                ; FIXME: find a way to get the receiving device ptr
        call    tcp_respond_segment
        jmp     .drop_no_socket
 
  .respond_seg_syn:
        mov     cl, TH_RST + TH_ACK
        xor     ebx, ebx                ; FIXME: find a way to get the receiving device ptr
        call    tcp_respond_segment
        jmp     .drop_no_socket
 
;------------------------------------------------
; Unlock socket mutex and prepare to drop segment
 
  .drop:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Dropping segment\n"
 
        pusha
        lea     ecx, [ebx + SOCKET.mutex]
        call    mutex_unlock
        popa
 
;--------------------------------------------
; Destroy the newly created socket if needed
 
  .destroy_new_socket:
        test    [temp_bits], TCP_BIT_DROPSOCKET
        jz      .drop_no_socket
 
        mov     eax, ebx
        call    socket_free
 
;------------------
; Drop the segment
 
  .drop_no_socket:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Drop (no socket)\n"
 
        call    net_buff_free
        jmp     .loop
 
endp
>
>
>
>

Rev 6476	Rev 6710
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2016. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2016. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;; Part of the TCP/IP network stack for KolibriOS ;;	6	;; Part of the TCP/IP network stack for KolibriOS ;;
7	;; ;;	7	;; ;;
8	;; Written by hidnplayr@kolibrios.org ;;	8	;; Written by hidnplayr@kolibrios.org ;;
9	;; ;;	9	;; ;;
10	;; Based on the algorithms used in 4.4BSD ;;	10	;; Based on the algorithms used in 4.4BSD ;;
11	;; ;;	11	;; ;;
12	;; GNU GENERAL PUBLIC LICENSE ;;	12	;; GNU GENERAL PUBLIC LICENSE ;;
13	;; Version 2, June 1991 ;;	13	;; Version 2, June 1991 ;;
14	;; ;;	14	;; ;;
15	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	15	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
16		16
17	$Revision: 6476 $	17	$Revision: 6710 $
18		18
19	TCP_BIT_NEEDOUTPUT = 1 shl 0	19	TCP_BIT_NEEDOUTPUT = 1 shl 0
20	TCP_BIT_TIMESTAMP = 1 shl 1	20	TCP_BIT_TIMESTAMP = 1 shl 1
21	TCP_BIT_DROPSOCKET = 1 shl 2	21	TCP_BIT_DROPSOCKET = 1 shl 2
22	TCP_BIT_FIN_IS_ACKED = 1 shl 3	22	TCP_BIT_FIN_IS_ACKED = 1 shl 3
23		23
24	;-----------------------------------------------------------------;	24	;-----------------------------------------------------------------;
25	; ;	25	; ;
26	; TCP_input: Add a segment to the incoming TCP queue. ;	26	; TCP_input: Add a segment to the incoming TCP queue. ;
27	; ;	27	; ;
28	; IN: [esp] = ptr to buffer ;	28	; IN: [esp] = ptr to buffer ;
29	; ebx = ptr to device struct ;	29	; ebx = ptr to device struct ;
30	; ecx = TCP segment size ;	30	; ecx = TCP segment size ;
31	; edx = ptr to IPv4 header ;	31	; edx = ptr to IPv4 header ;
32	; esi = ptr to TCP segment ;	32	; esi = ptr to TCP segment ;
33	; edi = interface number*4 ;	33	; edi = interface number*4 ;
34	; ;	34	; ;
35	; OUT: / ;	35	; OUT: / ;
36	; ;	36	; ;
37	;-----------------------------------------------------------------;	37	;-----------------------------------------------------------------;
38	align 4	38	align 4
39	tcp_input:	39	tcp_input:
40		40
41	; record the current time	41	; record the current time
42	push [timer_ticks] ; in 1/100 seconds	42	push [timer_ticks] ; in 1/100 seconds
43	push ebx ecx esi edx ; mind the order (see TCP_queue_entry struct)	43	push ebx ecx esi edx ; mind the order (see TCP_queue_entry struct)
44	mov esi, esp	44	mov esi, esp
45		45
46	push edi	46	push edi
47	add_to_queue TCP_queue, TCP_QUEUE_SIZE, sizeof.TCP_queue_entry, .fail	47	add_to_queue TCP_queue, TCP_QUEUE_SIZE, sizeof.TCP_queue_entry, .fail
48	pop edi	48	pop edi
49	add esp, sizeof.TCP_queue_entry	49	add esp, sizeof.TCP_queue_entry
50		50
51	inc [TCP_segments_rx + edi]	51	inc [TCP_segments_rx + edi]
52		52
53	xor edx, edx	53	xor edx, edx
54	mov eax, [TCP_input_event]	54	mov eax, [TCP_input_event]
55	mov ebx, [eax + EVENT.id]	55	mov ebx, [eax + EVENT.id]
56	xor esi, esi	56	xor esi, esi
57	call raise_event	57	call raise_event
58		58
59	ret	59	ret
60		60
61	.fail:	61	.fail:
62	pop edi	62	pop edi
63	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP incoming queue is full, discarding packet!\n"	63	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP incoming queue is full, discarding packet!\n"
64		64
65	call net_ptr_to_num4	65	call net_ptr_to_num4
66	inc [TCP_segments_missed + edi]	66	inc [TCP_segments_missed + edi]
67		67
68	add esp, sizeof.TCP_queue_entry - 4	68	add esp, sizeof.TCP_queue_entry - 4
69	call net_buff_free	69	call net_buff_free
70	ret	70	ret
71		71
72		72
73	;-----------------------------------------------------------------;	73	;-----------------------------------------------------------------;
74	; ;	74	; ;
75	; TCP_process_input: Process segments from the incoming TCP queue.;	75	; TCP_process_input: Process segments from the incoming TCP queue.;
76	; ;	76	; ;
77	; IN: / ;	77	; IN: / ;
78	; OUT: / ;	78	; OUT: / ;
79	; ;	79	; ;
80	;-----------------------------------------------------------------;	80	;-----------------------------------------------------------------;
81	align 4	81	align 4
82	proc tcp_process_input	82	proc tcp_process_input
83		83
84	locals	84	locals
85	dataoffset dd ?	85	dataoffset dd ?
86	timestamp dd ?	86	timestamp dd ?
87	temp_bits db ?	87	temp_bits db ?
88	endl	88	endl
89		89
90	xor esi, esi	90	xor esi, esi
91	mov ecx, MANUAL_DESTROY	91	mov ecx, MANUAL_DESTROY
92	call create_event	92	call create_event
93	mov [TCP_input_event], eax	93	mov [TCP_input_event], eax
94		94
95	.wait:	95	.wait:
96	mov eax, [TCP_input_event]	96	mov eax, [TCP_input_event]
97	mov ebx, [eax + EVENT.id]	97	mov ebx, [eax + EVENT.id]
98	call wait_event	98	call wait_event
99		99
100	.loop:	100	.loop:
101	get_from_queue TCP_queue, TCP_QUEUE_SIZE, sizeof.TCP_queue_entry, .wait	101	get_from_queue TCP_queue, TCP_QUEUE_SIZE, sizeof.TCP_queue_entry, .wait
102		102
103	push [esi + TCP_queue_entry.timestamp]	103	push [esi + TCP_queue_entry.timestamp]
104	pop [timestamp]	104	pop [timestamp]
105	push [esi + TCP_queue_entry.buffer_ptr]	105	push [esi + TCP_queue_entry.buffer_ptr]
106		106
107	mov ebx, [esi + TCP_queue_entry.device_ptr]	107	mov ebx, [esi + TCP_queue_entry.device_ptr]
108	mov ecx, [esi + TCP_queue_entry.segment_size]	108	mov ecx, [esi + TCP_queue_entry.segment_size]
109	mov edi, [esi + TCP_queue_entry.ip_ptr] ; ptr to ipv4 header	109	mov edi, [esi + TCP_queue_entry.ip_ptr] ; ptr to ipv4 header
110	mov esi, [esi + TCP_queue_entry.segment_ptr] ; change esi last	110	mov esi, [esi + TCP_queue_entry.segment_ptr] ; change esi last
111		111
112	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: size=%u time=%d\n", ecx, [timer_ticks]	112	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: size=%u time=%d\n", ecx, [timer_ticks]
113		113
114	mov edx, esi	114	mov edx, esi
115		115
116	; Verify the checksum (if not already done by hw)	116	; Verify the checksum (if not already done by hw)
117		117
118	test [ebx + NET_DEVICE.hwacc], NET_HWACC_TCP_IPv4_IN	118	test [ebx + NET_DEVICE.hwacc], NET_HWACC_TCP_IPv4_IN
119	jnz .checksum_ok	119	jnz .checksum_ok
120		120
121	push ecx esi	121	push ecx esi
122	pushw [esi + TCP_header.Checksum]	122	pushw [esi + TCP_header.Checksum]
123	mov [esi + TCP_header.Checksum], 0	123	mov [esi + TCP_header.Checksum], 0
124	tcp_checksum (edi+IPv4_header.SourceAddress), (edi+IPv4_header.DestinationAddress)	124	tcp_checksum (edi+IPv4_header.SourceAddress), (edi+IPv4_header.DestinationAddress)
125	pop cx ; previous checksum	125	pop cx ; previous checksum
126	cmp cx, dx	126	cmp cx, dx
127	pop edx ecx	127	pop edx ecx
128	jne .drop_no_socket	128	jne .drop_no_socket
129	.checksum_ok:	129	.checksum_ok:
130		130
131	; Verify the data offset	131	; Verify the data offset
132		132
133	movzx eax, [edx + TCP_header.DataOffset]	133	movzx eax, [edx + TCP_header.DataOffset]
134	and al, 0xf0 ; Calculate TCP segment header size (throwing away unused reserved bits in TCP header)	134	and al, 0xf0 ; Calculate TCP segment header size (throwing away unused reserved bits in TCP header)
135	shr al, 2	135	shr al, 2
136	cmp al, sizeof.TCP_header ; Now see if it's at least the size of a standard TCP header	136	cmp al, sizeof.TCP_header ; Now see if it's at least the size of a standard TCP header
137	jb .drop_no_socket ; If not, drop the packet	137	jb .drop_no_socket ; If not, drop the packet
138	mov [dataoffset], eax	138	mov [dataoffset], eax
139		139
140	sub ecx, eax ; substract TCP header size from total segment size	140	sub ecx, eax ; substract TCP header size from total segment size
141	jb .drop_no_socket ; If total segment size is less then the advertised header size, drop packet	141	jb .drop_no_socket ; If total segment size is less then the advertised header size, drop packet
142	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: %u bytes of data\n", ecx	142	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: %u bytes of data\n", ecx
143		143
144	;-------------------------------------------	144	;-------------------------------------------
145	; Convert Big-endian values to little endian	145	; Convert Big-endian values to little endian
146		146
147	ntohd [edx + TCP_header.SequenceNumber]	147	ntohd [edx + TCP_header.SequenceNumber]
148	ntohd [edx + TCP_header.AckNumber]	148	ntohd [edx + TCP_header.AckNumber]
149		149
150	ntohw [edx + TCP_header.Window]	150	ntohw [edx + TCP_header.Window]
151	ntohw [edx + TCP_header.UrgentPointer]	151	ntohw [edx + TCP_header.UrgentPointer]
152		152
153	;-----------------------------------------------------------------------------------	153	;-----------------------------------------------------------------------------------
154	;	154	;
155	; Find the socket pointer	155	; Find the socket pointer
156	;	156	;
157	;-----------------------------------------------------------------------------------	157	;-----------------------------------------------------------------------------------
158		158
159	; IP Packet TCP Destination Port = local Port	159	; IP Packet TCP Destination Port = local Port
160	; (IP Packet SenderAddress = Remote IP) OR (Remote IP = 0)	160	; (IP Packet SenderAddress = Remote IP) OR (Remote IP = 0)
161	; (IP Packet TCP Source Port = remote Port) OR (remote Port = 0)	161	; (IP Packet TCP Source Port = remote Port) OR (remote Port = 0)
162		162
163	.findpcb:	163	.findpcb:
164	pusha	164	pusha
165	mov ecx, socket_mutex	165	mov ecx, socket_mutex
166	call mutex_lock	166	call mutex_lock
167	popa	167	popa
168		168
169	mov ebx, net_sockets	169	mov ebx, net_sockets
170	mov si, [edx + TCP_header.DestinationPort]	170	mov si, [edx + TCP_header.DestinationPort]
171		171
172	.socket_loop:	172	.socket_loop:
173	mov ebx, [ebx + SOCKET.NextPtr]	173	mov ebx, [ebx + SOCKET.NextPtr]
174	or ebx, ebx	174	or ebx, ebx
175	jz .no_socket ;respond_seg_reset	175	jz .no_socket ;respond_seg_reset
176		176
177	cmp [ebx + SOCKET.Domain], AF_INET4	177	cmp [ebx + SOCKET.Domain], AF_INET4
178	jne .socket_loop	178	jne .socket_loop
179		179
180	cmp [ebx + SOCKET.Protocol], IP_PROTO_TCP	180	cmp [ebx + SOCKET.Protocol], IP_PROTO_TCP
181	jne .socket_loop	181	jne .socket_loop
182		182
183	cmp [ebx + TCP_SOCKET.LocalPort], si	183	cmp [ebx + TCP_SOCKET.LocalPort], si
184	jne .socket_loop	184	jne .socket_loop
185		185
186	mov eax, [ebx + IP_SOCKET.RemoteIP]	186	mov eax, [ebx + IP_SOCKET.RemoteIP]
187	cmp eax, [edi + IPv4_header.SourceAddress]	187	cmp eax, [edi + IPv4_header.SourceAddress]
188	je @f	188	je @f
189	test eax, eax	189	test eax, eax
190	jnz .socket_loop	190	jnz .socket_loop
191	@@:	191	@@:
192		192
193	mov ax, [ebx + TCP_SOCKET.RemotePort]	193	mov ax, [ebx + TCP_SOCKET.RemotePort]
194	cmp [edx + TCP_header.SourcePort], ax	194	cmp [edx + TCP_header.SourcePort], ax
195	je .found_socket	195	je .found_socket
196	test ax, ax	196	test ax, ax
197	jnz .socket_loop	197	jnz .socket_loop
198	.found_socket: ; ebx now contains the socketpointer	198	.found_socket: ; ebx now contains the socketpointer
199	pusha	199	pusha
200	mov ecx, socket_mutex	200	mov ecx, socket_mutex
201	call mutex_unlock	201	call mutex_unlock
202	popa	202	popa
203		203
204	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: socket ptr=%x state=%u flags=%x\n", ebx, [ebx + TCP_SOCKET.t_state], [edx + TCP_header.Flags]:2	204	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: socket ptr=%x state=%u flags=%x\n", ebx, [ebx + TCP_SOCKET.t_state], [edx + TCP_header.Flags]:2
205		205
206	;----------------------------	206	;----------------------------
207	; Check if socket isnt closed	207	; Check if socket isnt closed
208		208
209	cmp [ebx + TCP_SOCKET.t_state], TCPS_CLOSED	209	cmp [ebx + TCP_SOCKET.t_state], TCPS_CLOSED
210	je .drop_no_socket	210	je .drop_no_socket
211		211
212	;----------------	212	;----------------
213	; Lock the socket	213	; Lock the socket
214		214
215	pusha	215	pusha
216	lea ecx, [ebx + SOCKET.mutex]	216	lea ecx, [ebx + SOCKET.mutex]
217	call mutex_lock	217	call mutex_lock
218	popa	218	popa
219		219
220	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: socket locked\n"	220	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: socket locked\n"
221		221
222	;---------------------------	222	;---------------------------
223	; disable all temporary bits	223	; disable all temporary bits
224		224
225	mov [temp_bits], 0	225	mov [temp_bits], 0
226		226
227	;---------------------------------------	227	;---------------------------------------
228	; unscale the window into a 32 bit value	228	; unscale the window into a 32 bit value
229		229
230	movzx eax, [edx + TCP_header.Window]	230	movzx eax, [edx + TCP_header.Window]
231	push ecx	231	push ecx
232	mov cl, [ebx + TCP_SOCKET.SND_SCALE]	232	mov cl, [ebx + TCP_SOCKET.SND_SCALE]
233	shl eax, cl	233	shl eax, cl
234	mov dword[edx + TCP_header.Window], eax ; word after window is checksum, we dont need checksum anymore	234	mov dword[edx + TCP_header.Window], eax ; word after window is checksum, we dont need checksum anymore
235	pop ecx	235	pop ecx
236		236
237	;-----------------------------------------------------------------------------------	237	;-----------------------------------------------------------------------------------
238	;	238	;
239	; Accept incoming connections	239	; Accept incoming connections
240	;	240	;
241	;-----------------------------------------------------------------------------------	241	;-----------------------------------------------------------------------------------
242		242
243	test [ebx + SOCKET.options], SO_ACCEPTCON	243	test [ebx + SOCKET.options], SO_ACCEPTCON
244	jz .no_accept	244	jz .no_accept
245		245
246	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: Accepting new connection\n"	246	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: Accepting new connection\n"
247		247
248	; Unlock current socket	248	; Unlock current socket
249		249
250	pusha	250	pusha
251	lea ecx, [ebx + SOCKET.mutex]	251	lea ecx, [ebx + SOCKET.mutex]
252	call mutex_unlock	252	call mutex_unlock
253	popa	253	popa
254		254
255	; Fork it	255	; Fork it
256		256
257	push ecx edx esi edi	257	push ecx edx esi edi
258	call socket_fork	258	call socket_fork
259	pop edi esi edx ecx	259	pop edi esi edx ecx
260		260
261	test eax, eax	261	test eax, eax
262	jz .drop_no_socket	262	jz .drop_no_socket
263		263
264	; Success! Use the new socket from now on (it is already locked)	264	; Success! Use the new socket from now on (it is already locked)
265		265
266	mov ebx, eax	266	mov ebx, eax
267		267
268	mov [temp_bits], TCP_BIT_DROPSOCKET	268	mov [temp_bits], TCP_BIT_DROPSOCKET
269		269
270	push [edi + IPv4_header.DestinationAddress]	270	push [edi + IPv4_header.DestinationAddress]
271	pop [ebx + IP_SOCKET.LocalIP]	271	pop [ebx + IP_SOCKET.LocalIP]
272		272
273	push [edx + TCP_header.DestinationPort]	273	push [edx + TCP_header.DestinationPort]
274	pop [ebx + TCP_SOCKET.LocalPort]	274	pop [ebx + TCP_SOCKET.LocalPort]
275		275
276	mov [ebx + TCP_SOCKET.t_state], TCPS_LISTEN	276	mov [ebx + TCP_SOCKET.t_state], TCPS_LISTEN
277	.no_accept:	277	.no_accept:
278		278
279		279
280	;-------------------------------------	280	;-------------------------------------
281	; Reset idle timer and keepalive timer	281	; Reset idle timer and keepalive timer
282		282
283	mov [ebx + TCP_SOCKET.t_idle], 0	283	mov [ebx + TCP_SOCKET.t_idle], 0
284	mov [ebx + TCP_SOCKET.timer_keepalive], TCP_time_keep_idle	284	mov [ebx + TCP_SOCKET.timer_keepalive], TCP_time_keep_idle
285	or [ebx + TCP_SOCKET.timer_flags], timer_flag_keepalive	285	or [ebx + TCP_SOCKET.timer_flags], timer_flag_keepalive
286		286
287	;-----------------------------------------------------------------------------------	287	;-----------------------------------------------------------------------------------
288	;	288	;
289	; Process TCP options	289	; Process TCP options
290	;	290	;
291	;-----------------------------------------------------------------------------------	291	;-----------------------------------------------------------------------------------
292		292
293	;;; FIXME: for LISTEN, options should be called after we determined route, we need it for MSS	293	;;; FIXME: for LISTEN, options should be called after we determined route, we need it for MSS
294	;;; cmp [ebx + TCP_SOCKET.t_state], TCPS_LISTEN ; no options when in listen state	294	;;; cmp [ebx + TCP_SOCKET.t_state], TCPS_LISTEN ; no options when in listen state
295	;;; jz .not_uni_xfer ; also no header prediction	295	;;; jz .not_uni_xfer ; also no header prediction
296		296
297	push ecx	297	push ecx
298		298
299	mov ecx, [dataoffset]	299	mov ecx, [dataoffset]
300	cmp ecx, sizeof.TCP_header ; Does header contain any options?	300	cmp ecx, sizeof.TCP_header ; Does header contain any options?
301	je .no_options	301	je .no_options
302		302
303	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: Segment has options\n"	303	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: Segment has options\n"
304		304
305	add ecx, edx	305	add ecx, edx
306	lea esi, [edx + sizeof.TCP_header]	306	lea esi, [edx + sizeof.TCP_header]
307		307
308	.opt_loop:	308	.opt_loop:
309	cmp esi, ecx ; are we scanning outside of header?	309	cmp esi, ecx ; are we scanning outside of header?
310	jae .no_options	310	jae .no_options
311	lodsb	311	lodsb
312	cmp al, TCP_OPT_EOL ; end of option list?	312	cmp al, TCP_OPT_EOL ; end of option list?
313	je .no_options	313	je .no_options
314	cmp al, TCP_OPT_NOP	314	cmp al, TCP_OPT_NOP
315	je .opt_loop	315	je .opt_loop
316	cmp al, TCP_OPT_MAXSEG	316	cmp al, TCP_OPT_MAXSEG
317	je .opt_maxseg	317	je .opt_maxseg
318	cmp al, TCP_OPT_WINDOW	318	cmp al, TCP_OPT_WINDOW
319	je .opt_window	319	je .opt_window
320	cmp al, TCP_OPT_SACK_PERMIT	320	cmp al, TCP_OPT_SACK_PERMIT
321	je .opt_sack_permit	321	je .opt_sack_permit
322	; cmp al, TCP_OPT_SACK	322	; cmp al, TCP_OPT_SACK
323	; je .opt_sack	323	; je .opt_sack
324	cmp al, TCP_OPT_TIMESTAMP	324	cmp al, TCP_OPT_TIMESTAMP
325	je .opt_timestamp	325	je .opt_timestamp
326	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: unknown option:%u\n", al	326	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: unknown option:%u\n", al
327	jmp .no_options ; If we reach here, some unknown options were received, skip them all!	327	jmp .no_options ; If we reach here, some unknown options were received, skip them all!
328		328
329	.opt_maxseg:	329	.opt_maxseg:
330	lodsb	330	lodsb
331	cmp al, 4	331	cmp al, 4
332	jne .no_options ; error occured, ignore all options!	332	jne .no_options ; error occured, ignore all options!
333		333
334	test [edx + TCP_header.Flags], TH_SYN	334	test [edx + TCP_header.Flags], TH_SYN
335	jz @f	335	jz @f
336		336
337	xor eax, eax	337	xor eax, eax
338	lodsw	338	lodsw
339	rol ax, 8	339	rol ax, 8
340	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: Maxseg=%u\n", eax	340	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: Maxseg=%u\n", eax
341	call tcp_mss	341	call tcp_mss
342	@@:	342	@@:
343	jmp .opt_loop	343	jmp .opt_loop
344		344
345		345
346	.opt_window:	346	.opt_window:
347	lodsb	347	lodsb
348	cmp al, 3	348	cmp al, 3
349	jne .no_options	349	jne .no_options
350		350
351	test [edx + TCP_header.Flags], TH_SYN	351	test [edx + TCP_header.Flags], TH_SYN
352	jz @f	352	jz @f
353		353
354	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: Got window scale option\n"	354	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: Got window scale option\n"
355	or [ebx + TCP_SOCKET.t_flags], TF_RCVD_SCALE	355	or [ebx + TCP_SOCKET.t_flags], TF_RCVD_SCALE
356		356
357	lodsb	357	lodsb
358	mov [ebx + TCP_SOCKET.SND_SCALE], al	358	mov [ebx + TCP_SOCKET.SND_SCALE], al
359	;;;;; TODO	359	;;;;; TODO
360		360
361	@@:	361	@@:
362	jmp .opt_loop	362	jmp .opt_loop
363		363
364		364
365	.opt_sack_permit:	365	.opt_sack_permit:
366	lodsb	366	lodsb
367	cmp al, 2	367	cmp al, 2
368	jne .no_options	368	jne .no_options
369		369
370	test [edx + TCP_header.Flags], TH_SYN	370	test [edx + TCP_header.Flags], TH_SYN
371	jz @f	371	jz @f
372		372
373	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: Selective Acknowledgement permitted\n"	373	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: Selective Acknowledgement permitted\n"
374	or [ebx + TCP_SOCKET.t_flags], TF_SACK_PERMIT	374	or [ebx + TCP_SOCKET.t_flags], TF_SACK_PERMIT
375		375
376	@@:	376	@@:
377	jmp .opt_loop	377	jmp .opt_loop
378		378
379		379
380	.opt_timestamp:	380	.opt_timestamp:
381	lodsb	381	lodsb
382	cmp al, 10 ; length must be 10	382	cmp al, 10 ; length must be 10
383	jne .no_options	383	jne .no_options
384		384
385	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: Got timestamp option\n"	385	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: Got timestamp option\n"
386		386
387	test [edx + TCP_header.Flags], TH_SYN	387	test [edx + TCP_header.Flags], TH_SYN
388	jz @f	388	jz @f
389	or [ebx + TCP_SOCKET.t_flags], TF_RCVD_TSTMP	389	or [ebx + TCP_SOCKET.t_flags], TF_RCVD_TSTMP
390	@@:	390	@@:
391		391
392	lodsd	392	lodsd
393	bswap eax	393	bswap eax
394	mov [ebx + TCP_SOCKET.ts_val], eax	394	mov [ebx + TCP_SOCKET.ts_val], eax
395	lodsd ; timestamp echo reply	395	lodsd ; timestamp echo reply
396	mov [ebx + TCP_SOCKET.ts_ecr], eax	396	mov [ebx + TCP_SOCKET.ts_ecr], eax
397	or [temp_bits], TCP_BIT_TIMESTAMP	397	or [temp_bits], TCP_BIT_TIMESTAMP
398		398
399	; Since we have a timestamp, lets do the paws test right away!	399	; Since we have a timestamp, lets do the paws test right away!
400		400
401	test [edx + TCP_header.Flags], TH_RST	401	test [edx + TCP_header.Flags], TH_RST
402	jnz .no_paws	402	jnz .no_paws
403		403
404	mov eax, [ebx + TCP_SOCKET.ts_recent]	404	mov eax, [ebx + TCP_SOCKET.ts_recent]
405	test eax, eax	405	test eax, eax
406	jz .no_paws	406	jz .no_paws
407	cmp eax, [ebx + TCP_SOCKET.ts_val]	407	cmp eax, [ebx + TCP_SOCKET.ts_val]
408	jbe .no_paws	408	jbe .no_paws
409		409
410	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: PAWS: detected an old segment\n"	410	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: PAWS: detected an old segment\n"
411		411
412	mov eax, [timestamp]	412	mov eax, [timestamp]
413	sub eax, [ebx + TCP_SOCKET.ts_recent_age]	413	sub eax, [ebx + TCP_SOCKET.ts_recent_age]
414		414
415	pop ecx	415	pop ecx
416	cmp eax, TCP_PAWS_IDLE	416	cmp eax, TCP_PAWS_IDLE
417	jle .paws_drop	417	jle .paws_drop
418	push ecx	418	push ecx
419	mov [ebx + TCP_SOCKET.ts_recent], 0 ; timestamp was invalid, fix it.	419	mov [ebx + TCP_SOCKET.ts_recent], 0 ; timestamp was invalid, fix it.
420	.no_paws:	420	.no_paws:
421	jmp .opt_loop	421	jmp .opt_loop
422		422
423	.paws_drop:	423	.paws_drop:
424	inc [TCPS_rcvduppack]	424	inc [TCPS_rcvduppack]
425	add [TCPS_rcvdupbyte], ecx	425	add [TCPS_rcvdupbyte], ecx
426	inc [TCPS_pawsdrop]	426	inc [TCPS_pawsdrop]
427	jmp .drop_after_ack	427	jmp .drop_after_ack
428		428
429	.no_options:	429	.no_options:
430		430
431	pop ecx	431	pop ecx
432		432
433	;-----------------------------------------------------------------------------------	433	;-----------------------------------------------------------------------------------
434	;	434	;
435	; Header prediction	435	; Header prediction
436	;	436	;
437	;-----------------------------------------------------------------------------------	437	;-----------------------------------------------------------------------------------
438		438
439	; According to Van Jacobson, there are two common cases for an uni-directional data transfer.	439	; According to Van Jacobson, there are two common cases for an uni-directional data transfer.
440	;	440	;
441	; General rule: the packets has no control flags, is in-sequence,	441	; General rule: the packets has no control flags, is in-sequence,
442	; window width didnt change and we're not retransmitting.	442	; window width didnt change and we're not retransmitting.
443	;	443	;
444	; Second rules:	444	; Second rules:
445	; - If the length is 0 and the ACK moved forward, we're the sender side of the transfer.	445	; - If the length is 0 and the ACK moved forward, we're the sender side of the transfer.
446	; In this case we'll free the ACK'ed data and notify higher levels that we have free space in buffer	446	; In this case we'll free the ACK'ed data and notify higher levels that we have free space in buffer
447	;	447	;
448	; - If the length is not 0 and the ACK didn't move, we're the receiver side of the transfer.	448	; - If the length is not 0 and the ACK didn't move, we're the receiver side of the transfer.
449	; If the packets are in order (data queue is empty), add the data to the socket buffer and request a delayed ACK	449	; If the packets are in order (data queue is empty), add the data to the socket buffer and request a delayed ACK
450		450
451	cmp [ebx + TCP_SOCKET.t_state], TCPS_ESTABLISHED	451	cmp [ebx + TCP_SOCKET.t_state], TCPS_ESTABLISHED
452	jnz .not_uni_xfer	452	jnz .not_uni_xfer
453		453
454	test [edx + TCP_header.Flags], TH_SYN + TH_FIN + TH_RST + TH_URG	454	test [edx + TCP_header.Flags], TH_SYN + TH_FIN + TH_RST + TH_URG
455	jnz .not_uni_xfer	455	jnz .not_uni_xfer
456		456
457	test [edx + TCP_header.Flags], TH_ACK	457	test [edx + TCP_header.Flags], TH_ACK
458	jz .not_uni_xfer	458	jz .not_uni_xfer
459		459
460	mov eax, [edx + TCP_header.SequenceNumber]	460	mov eax, [edx + TCP_header.SequenceNumber]
461	cmp eax, [ebx + TCP_SOCKET.RCV_NXT]	461	cmp eax, [ebx + TCP_SOCKET.RCV_NXT]
462	jne .not_uni_xfer	462	jne .not_uni_xfer
463		463
464	mov eax, dword[edx + TCP_header.Window]	464	mov eax, dword[edx + TCP_header.Window]
465	cmp eax, [ebx + TCP_SOCKET.SND_WND]	465	cmp eax, [ebx + TCP_SOCKET.SND_WND]
466	jne .not_uni_xfer	466	jne .not_uni_xfer
467		467
468	mov eax, [ebx + TCP_SOCKET.SND_NXT]	468	mov eax, [ebx + TCP_SOCKET.SND_NXT]
469	cmp eax, [ebx + TCP_SOCKET.SND_MAX]	469	cmp eax, [ebx + TCP_SOCKET.SND_MAX]
470	jne .not_uni_xfer	470	jne .not_uni_xfer
471		471
472	;---------------------------------------	472	;---------------------------------------
473	; check if we are sender in the uni-xfer	473	; check if we are sender in the uni-xfer
474		474
475	; If the following 4 conditions are all true, this segment is a pure ACK.	475	; If the following 4 conditions are all true, this segment is a pure ACK.
476	;	476	;
477	; - The segment contains no data.	477	; - The segment contains no data.
478		478
479	test ecx, ecx	479	test ecx, ecx
480	jnz .not_sender	480	jnz .not_sender
481		481
482	; - The congestion window is greater than or equal to the current send window.	482	; - The congestion window is greater than or equal to the current send window.
483	; 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.	483	; 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.
484		484
485	mov eax, [ebx + TCP_SOCKET.SND_CWND]	485	mov eax, [ebx + TCP_SOCKET.SND_CWND]
486	cmp eax, [ebx + TCP_SOCKET.SND_WND]	486	cmp eax, [ebx + TCP_SOCKET.SND_WND]
487	jb .not_uni_xfer	487	jb .not_uni_xfer
488		488
489	; - The acknowledgment field in the segment is less than or equal to the maximum sequence number sent.	489	; - The acknowledgment field in the segment is less than or equal to the maximum sequence number sent.
490		490
491	mov eax, [edx + TCP_header.AckNumber]	491	mov eax, [edx + TCP_header.AckNumber]
492	cmp eax, [ebx + TCP_SOCKET.SND_MAX]	492	cmp eax, [ebx + TCP_SOCKET.SND_MAX]
493	ja .not_uni_xfer	493	ja .not_uni_xfer
494		494
495	; - The acknowledgment field in the segment is greater than the largest unacknowledged sequence number.	495	; - The acknowledgment field in the segment is greater than the largest unacknowledged sequence number.
496		496
497	sub eax, [ebx + TCP_SOCKET.SND_UNA]	497	sub eax, [ebx + TCP_SOCKET.SND_UNA]
498	jbe .not_uni_xfer	498	jbe .not_uni_xfer
499		499
500	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: Header prediction: we are sender\n"	500	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: Header prediction: we are sender\n"

Subversion Repositories Kolibri OS

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