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


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

Subversion Repositories Kolibri OS

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