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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2013. 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 code of 4.4BSD                                  ;;
;;                                                                 ;;
;;          GNU GENERAL PUBLIC LICENSE                             ;;
;;             Version 2, June 1991                                ;;
;;                                                                 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 3407 $
 
;-----------------------------------------------------------------
;
; TCP_input:
;
;       Add a segment to the incoming TCP queue
;
;  IN:  [esp] = ptr to buffer
;       [esp+4] = buffer size (dont care)
;       ebx = ptr to device struct
;       ecx = segment size
;       esi = ptr to TCP segment
;       edi = ptr to ipv4 source address, followed by ipv4 dest address
;
;  OUT: /
;
;-----------------------------------------------------------------
 
align 4
TCP_input:
 
; record the current time
        mov     eax, [timer_ticks]      ; in 1/100 seconds
        mov     [esp + 4], eax
 
        push    ebx ecx esi edi         ; mind the order
        mov     esi, esp
 
        pushf
        cli
        add_to_queue TCP_queue, TCP_QUEUE_SIZE, sizeof.TCP_queue_entry, .fail
        popf
 
        add     esp, sizeof.TCP_queue_entry
 
        call    NET_ptr_to_num4
        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:
        popf
        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 - 8
        call    kernel_free
        add     esp, 4
 
        ret
 
 
 
 
align 4
TCP_process_input:
 
        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]
        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 source address, followed by ipv4 destination address
        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
 
        cmp     ebx, LOOPBACK_DEVICE
        je      .checksum_ok
 
; re-calculate the checksum (if not already done by hw)
;        test    [ebx + NET_DEVICE.hwacc], HWACC_TCP_IPv4_IN
;        jnz     .checksum_ok
 
        push    ecx esi
        pushw   [esi + TCP_header.Checksum]
        mov     [esi + TCP_header.Checksum], 0
        TCP_checksum (edi), (edi+4)
        pop     cx                      ; previous checksum
        cmp     cx, dx
        pop     edx ecx
        jne     .drop_no_socket
  .checksum_ok:
 
; Verify the data offset
        and     [edx + TCP_header.DataOffset], 0xf0                     ; Calculate TCP segment header size (throwing away unused reserved bits in TCP header)
        shr     [edx + TCP_header.DataOffset], 2
        cmp     [edx + TCP_header.DataOffset], 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
 
        movzx   eax, [edx + TCP_header.DataOffset]
        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 source address
        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     [ebx + TCP_SOCKET.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
 
;---------------------------------------
; Are we accepting incoming connections?
 
        test    [ebx + SOCKET.options], SO_ACCEPTCON
        jz      .no_accept
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Accepting new connection\n"
 
        pusha
        lea     ecx, [ebx + SOCKET.mutex]
        call    mutex_unlock
        popa
 
        push    ecx edx esi edi         ;;;
        call    SOCKET_fork
        pop     edi esi edx ecx
 
        test    eax, eax
        jz      .drop_no_socket
 
        mov     ebx, eax
 
        mov     [ebx + TCP_SOCKET.temp_bits], TCP_BIT_DROPSOCKET        ;;; FIXME: should we take over bits from previous socket?
 
        push    dword [edi + 4]                         ; Ipv4 destination addres
        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
 
        push    ecx
 
        movzx   ecx, [edx + TCP_header.DataOffset]
        cmp     ecx, sizeof.TCP_header                  ; Does header contain any options?
        je      .no_options
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Segment has options\n"
 
;;; 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
 
        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
 
        lodsw
        rol     ax, 8
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Maxseg=%u\n", ax
        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
        mov     [ebx + TCP_SOCKET.ts_val], eax
        lodsd                                   ; timestamp echo reply
        mov     [ebx + TCP_SOCKET.ts_ecr], eax
        or      [ebx + TCP_SOCKET.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]
        jge     .no_paws
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: PAWS: detected an old segment\n"
 
        mov     eax, [esp+4+4]                          ; tcp_now
        sub     eax, [ebx + TCP_SOCKET.ts_recent_age]
 
        pop     ecx
        cmp     eax, TCP_PAWS_IDLE
        jle     .drop_after_ack                         ; TODO: update stats
        push    ecx
 
        mov     [ebx + TCP_SOCKET.ts_recent], 0         ; timestamp was invalid, fix it.
  .no_paws:
        jmp     .opt_loop
 
  .no_options:
 
        pop     ecx
 
;-----------------------------------------------------------------------
; Time to do some header prediction (Original Principle by 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
 
; 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    [ebx + TCP_SOCKET.temp_bits], TCP_BIT_TIMESTAMP
        jz      .no_timestamp_rtt
        mov     eax, [esp + 4]                          ; timestamp when this segment was received
        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 (seg_next equals tp).
 
;;; TODO
 
;       jnz     .not_uni_xfer
 
; Complete processing of received data
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Header prediction: we are receiving %u bytes\n", ecx
 
        add     [ebx + TCP_SOCKET.RCV_NXT], ecx         ; Update sequence number with number of bytes we have copied
 
        movzx   esi, [edx + TCP_header.DataOffset]
        add     esi, edx
        lea     eax, [ebx + STREAM_SOCKET.rcv]
        call    SOCKET_ring_write                       ; Add the data to the socket buffer
 
        mov     eax, ebx
        call    SOCKET_notify
 
        or      [ebx + TCP_SOCKET.t_flags], TF_DELACK   ; Set delayed ack flag
 
        jmp     .drop
 
;--------------------------------------------------
; Header prediction failed, do it the slow way
 
  .not_uni_xfer:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Header prediction failed\n"
 
; Calculate receive window size
 
        push    edx
        mov     eax, SOCKETBUFFSIZE
        sub     eax, [ebx + STREAM_SOCKET.rcv.size]
        mov     edx, [ebx + TCP_SOCKET.RCV_ADV]
        sub     edx, [ebx + TCP_SOCKET.RCV_NXT]
        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      .LISTEN
 
        cmp     [ebx + TCP_SOCKET.t_state], TCPS_SYN_SENT
        je      .SYN_SENT
 
;----------------------------
; trim any data not in window
 
; check for duplicate data at beginning of segment (635)
 
        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
 
        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 (646)
        cmp     eax, ecx                ; eax holds number of bytes to drop, ecx is data size
        jb      .duplicate
        jnz     @f
        test    [edx + TCP_header.Flags], TH_FIN
        jnz     .duplicate
       @@:
 
; 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 and resynchronize and drop any data.
; But keep on processing for RST or ACK
        DEBUGF  DEBUG_NETWORK_VERBOSE,  "616\n"
        or      [ebx + TCP_SOCKET.t_flags], TF_ACKNOW
        mov     eax, ecx
;TODO: update stats
 
;-----------------------------------------------
; Remove duplicate data and update urgent offset
 
  .duplicate:
;;; TODO: 677
        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
       @@:
 
;--------------------------------------------------
; Handle data that arrives after process terminates (687)
 
  .no_duplicate:
        cmp     [ebx + SOCKET.PID], 0
        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
;;;TODO: update stats
        jmp     .respond_seg_reset
 
;----------------------------------------
; Remove data beyond right edge of window (700-736)
 
  .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
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "%d bytes beyond right edge of window\n", eax
 
;;; TODO: update stats
        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
        cmp     [ebx + TCP_SOCKET.t_state], TCPS_TIMED_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 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     eax, [edx + TCP_header.SequenceNumber]
        cmp     eax, [ebx + TCP_SOCKET.RCV_NXT]
        jne     .drop_after_ack
 
        DEBUGF  DEBUG_NETWORK_VERBOSE,  "690\n"
        or      [ebx + TCP_SOCKET.t_flags], TF_ACKNOW
;;; TODO: update stats
        jmp     .no_excess_data
  .dont_drop_all:
;;; TODO: update stats
;;; TODO: 733
 
        sub     ecx, eax
        and     [ebx + TCP_SOCKET.t_flags], not (TH_PUSH or TH_FIN)
  .no_excess_data:
 
;-----------------
; Record timestamp (737-746)
 
; If last ACK falls within this segments sequence numbers, record its timestamp
        test    [ebx + TCP_SOCKET.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
        jz      @f
        dec     eax
       @@:
        sub     eax, ecx
        jae     .no_timestamp
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "Recording timestamp\n"
 
        mov     eax, [esp + 4]                                  ; tcp_now
        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 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]
        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_TIMED_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
;;; TODO: update stats (tcp drops)
        mov     eax, ebx
        call    TCP_close
        jmp     .drop_no_socket
 
  .rst_close:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Closing with reset\n"
 
        mov     eax, ebx
        call    TCP_close
        jmp     .drop_no_socket
 
  .no_rst:
 
;--------------------------------------
; handle SYN-full and ACK-less segments
 
        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:
 
;---------------
; ACK processing
 
        test    [edx + TCP_header.Flags], TH_ACK
        jz      .drop
 
        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
 
;;; TODO: update stats
 
        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]
       @@:
 
;;; TODO: call TCP_reassemble
 
        mov     eax, [edx + TCP_header.SequenceNumber]
        dec     eax
        mov     [ebx + TCP_SOCKET.SND_WL1], eax
 
  .no_syn_rcv:
 
;-------------------------
; check for duplicate ACKs
 
        mov     eax, [edx + TCP_header.AckNumber]
        cmp     eax, [ebx + TCP_SOCKET.SND_UNA]
        ja      .not_dup_ack
 
        test    ecx, ecx
        jnz     .reset_dupacks
 
        mov     eax, dword [edx + TCP_header.Window]
        cmp     eax, [ebx + TCP_SOCKET.SND_WND]
        jne     .reset_dupacks
 
        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      @f
 
        mov     eax, [edx + TCP_header.AckNumber]
        cmp     eax, [ebx + TCP_SOCKET.SND_UNA]
        je      .dup_ack
 
       @@:
        mov     [ebx + TCP_SOCKET.t_dupacks], 0
        jmp     .not_dup_ack
 
  .dup_ack:
        inc     [ebx + TCP_SOCKET.t_dupacks]
        cmp     [ebx + TCP_SOCKET.t_dupacks], TCP_re_xmit_thresh
        jne     .no_re_xmit
 
        push    [ebx + TCP_SOCKET.SND_NXT]              ; >>>>
 
        mov     eax, [ebx + TCP_SOCKET.SND_WND]
        cmp     eax, [ebx + TCP_SOCKET.SND_CWND]
        cmova   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
 
 
  .no_re_xmit:
        jbe     .not_dup_ack
 
        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
        mov     eax, [esp]
        call    TCP_output
 
; Lock the socket again
        mov     ecx, [esp]
        add     ecx, SOCKET.mutex
        call    mutex_lock
        pop     ebx
 
        jmp     .drop
 
 
  .not_dup_ack:
 
;-------------------------------------------------
; 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
 
        ;;; TODO: update stats
        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
 
        ;;; TODO: update stats
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: acceptable ACK for %u bytes\n", edi
 
;------------------------------------------
; RTT measurements and retransmission timer  (912-926)
 
; If we have a timestamp, update smoothed RTT
 
        test    [ebx + TCP_SOCKET.temp_bits], TCP_BIT_TIMESTAMP
        jz      .timestamp_not_present
        mov     eax, [esp+4]
        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      [ebx + TCP_SOCKET.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
 
        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
        div     esi
        pop     edx
        shr     edx, 3
        add     eax, edx
        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
        cmova   esi, eax
        mov     [ebx + TCP_SOCKET.SND_CWND], esi
 
;------------------------------------------
; Remove acknowledged data from send buffer
 
        cmp     edi, [ebx + STREAM_SOCKET.snd.size]
        jbe     .finiacked
 
        push    ecx edx ebx
        mov     ecx, [ebx + STREAM_SOCKET.snd.size]
        lea     eax, [ebx + STREAM_SOCKET.snd]
        sub     [ebx + TCP_SOCKET.SND_WND], ecx
        call    SOCKET_ring_free
        pop     ebx edx ecx
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: our FIN is acked\n"
        stc
 
        jmp     .wakeup
 
  .finiacked:
 
        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
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: our FIN is not acked\n"
        clc
 
;----------------------------------------
; Wake up process waiting on send buffer
 
  .wakeup:
 
        pushf                   ; Keep the flags (Carry flag)
        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
       @@:
 
        popf
 
; General ACK handling complete
; Now do the state-specific ones
; Carry flag is set when our FIN is acked
 
        mov     eax, [ebx + TCP_SOCKET.t_state]
        jmp     dword [eax*4 + .ACK_sw_list]
 
  .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:
        jnc     .ack_processed
 
        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:
        jnc     .ack_processed
 
        mov     [ebx + TCP_SOCKET.t_state], TCPS_TIMED_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:
        jnc     .ack_processed
 
        push    ebx
        lea     ecx, [ebx + SOCKET.mutex]
        call    mutex_unlock
        pop     ebx
 
        push    ebx
        mov     eax, ebx
        call    TCP_disconnect
        pop     ebx
 
        jmp     .destroy_new_socket
 
  .ack_tw:
        mov     [ebx + TCP_SOCKET.timer_timed_wait], 2 * TCP_time_MSL
        or      [ebx + TCP_SOCKET.timer_flags], timer_flag_wait
        jmp     .drop_after_ack
 
  .reset_dupacks:               ; We got a new ACK, reset duplicate ACK counter
        mov     [ebx + TCP_SOCKET.t_dupacks], 0
        jmp     .ack_processed
 
;-------
; LISTEN
 
align 4
  .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
 
;;; TODO: check if it's a broadcast or multicast, and drop if so
 
        push    dword [edi]                             ; Ipv4 source addres
        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], 64000 / 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
        mov     [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
 
        lea     eax, [ebx + STREAM_SOCKET.rcv]
        call    SOCKET_ring_create
 
        and     [ebx + TCP_SOCKET.temp_bits], not TCP_BIT_DROPSOCKET
 
        pusha
        mov     eax, ebx
        call    SOCKET_notify
        popa
 
        jmp     .trim_then_step6
 
;------------
; Active Open
 
align 4
  .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
       @@:
 
        test    [edx + TCP_header.Flags], TH_SYN
        jz      .drop
 
; at this point, segment seems to be valid
 
        test    [edx + TCP_header.Flags], TH_ACK
        jz      .no_syn_ack
 
; now, process received SYN in response to an active open
 
        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
       @@:
 
  .no_syn_ack:
        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"
 
;;; TODO: update stats
 
; 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
 
        mov     eax, [ebx + TCP_SOCKET.t_rtt]
        test    eax, eax
        je      .trim_then_step6
        call    TCP_xmit_timer
        jmp     .trim_then_step6
 
  .simultaneous_open:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: simultaneous open\n"
; We have received a syn but no ACK, so we are having a simultaneous open..
        mov     [ebx + TCP_SOCKET.t_state], TCPS_SYN_RECEIVED
 
;-------------------------------------
; Common processing for receipt of SYN
 
  .trim_then_step6:
 
        inc     [edx + TCP_header.SequenceNumber]
 
;;; TODO: Drop any received data that follows receive window (590)
 
        mov     eax, [edx + TCP_header.SequenceNumber]
        mov     [ebx + TCP_SOCKET.RCV_UP], eax
        dec     eax
        mov     [ebx + TCP_SOCKET.SND_WL1], eax
 
;-------
; step 6
 
  .ack_processed:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: ACK processed\n"
 
;----------------------------------------------
; check if we need to update window information
 
        test    [edx + TCP_header.Flags], TH_ACK
        jz      .no_window_update
 
        mov     eax, [ebx + TCP_SOCKET.SND_WL1]
        cmp     eax, [edx + TCP_header.SequenceNumber]
        jb      .update_window
        ja      @f
 
        mov     eax, [ebx + TCP_SOCKET.SND_WL2]
        cmp     eax, [edx + TCP_header.AckNumber]
        jb      .update_window
        ja      .no_window_update
       @@:
 
        mov     eax, dword [edx + TCP_header.Window]
        cmp     eax, [ebx + TCP_SOCKET.SND_WND]
        jbe     .no_window_update
 
  .update_window:
 
;;; TODO: update stats (Keep track of pure window updates)
 
        mov     eax, dword [edx + TCP_header.Window]
        cmp     eax, [ebx + TCP_SOCKET.max_sndwnd]
        jbe     @f
        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
 
        push    [edx + TCP_header.SequenceNumber]
        pop     [ebx + TCP_SOCKET.SND_WL1]
 
        push    [edx + TCP_header.AckNumber]
        pop     [ebx + TCP_SOCKET.SND_WL2]
 
        or      [ebx + TCP_SOCKET.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_TIMED_WAIT
        je      .not_urgent
 
; Ignore bogus urgent offsets
 
        movzx   eax, [edx + TCP_header.UrgentPointer]
        add     eax, [ebx + STREAM_SOCKET.rcv.size]
        cmp     eax, SOCKET_MAXDATA
        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 in the segment (1094)
 
  .do_data:
 
        cmp     [ebx + TCP_SOCKET.t_state], TCPS_TIMED_WAIT
        jae     .final_processing
 
        test    [edx + TCP_header.Flags], TH_FIN
        jnz     @f
 
        test    ecx, ecx
        jnz     .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
        movzx   esi, [edx + TCP_header.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:
 
; Uh-oh, some data is out of order, lets call TCP reassemble for help
 
        call    TCP_reassemble
 
        DEBUGF  DEBUG_NETWORK_VERBOSE,  "1470\n"
        or      [ebx + TCP_SOCKET.t_flags], TF_ACKNOW
 
  .data_done:
 
;---------------
; FIN processing
 
        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_TIMED_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
 
        mov     [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
        jmp     dword [eax + .FIN_sw_list]
 
  .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:
 
        mov     [ebx + TCP_SOCKET.t_state], TCPS_CLOSE_WAIT
        jmp     .final_processing
 
  .fin_wait1:
 
        mov     [ebx + TCP_SOCKET.t_state], TCPS_CLOSING
        jmp     .final_processing
 
  .fin_wait2:
 
        mov     [ebx + TCP_SOCKET.t_state], TCPS_TIMED_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
        call    SOCKET_is_disconnected
        jmp     .final_processing
 
  .fin_timed:
        mov     [ebx + TCP_SOCKET.timer_timed_wait], 2 * TCP_time_MSL
        or      [ebx + TCP_SOCKET.timer_flags], timer_flag_wait
        jmp     .final_processing
 
 
  .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     .dumpit
 
        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     .dumpit
 
        ;;; 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     .dumpit
 
;-----------------
; Final processing
 
  .final_processing:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Final processing\n"
 
        push    ebx
        lea     ecx, [ebx + SOCKET.mutex]
        call    mutex_unlock
        pop     eax
 
        test    [eax + TCP_SOCKET.temp_bits], TCP_BIT_NEEDOUTPUT
        jnz     .need_output
 
        test    [eax + TCP_SOCKET.t_flags], TF_ACKNOW
        jz      .dumpit
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: ACK now!\n"
 
  .need_output:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: need output\n"
        call    TCP_output
 
  .dumpit:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: dumping\n"
 
        call    kernel_free
        add     esp, 4
        jmp     .loop
 
;---------
; Respond
 
  .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
 
  .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
        call    TCP_respond_segment
        jmp     .drop_no_socket
 
  .respond_seg_syn:
        mov     cl, TH_RST + TH_ACK
        call    TCP_respond_segment
        jmp     .drop_no_socket
 
;-----
; Drop
 
  .drop:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Dropping segment\n"
 
        pusha
        lea     ecx, [ebx + SOCKET.mutex]
        call    mutex_unlock
        popa
 
  .destroy_new_socket:
        test    [ebx + TCP_SOCKET.temp_bits], TCP_BIT_DROPSOCKET
        jz      .drop_no_socket
 
        mov     eax, ebx
        call    SOCKET_free
 
  .drop_no_socket:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Drop (no socket)\n"
 
        call    kernel_free
        add     esp, 4
        jmp     .loop
>
>
>
>

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/network/tcp_input.inc – Rev 3652 → 3674