WebSVN – Kolibri OS – Diff – /kernel/branches/Kolibri-acpi/network/tcp_input.inc

+align 4
+proc TCP_process_input
+locals
         dataoffset      dd ?
         timestamp       dd ?
-align 4
+        temp_bits       db ?
-TCP_process_input:
+endl
   .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.timestamp]
+        pop     [timestamp]
         push    [esi + TCP_queue_entry.buffer_ptr]
         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
+        test    [ebx + NET_DEVICE.hwacc], NET_HWACC_TCP_IPv4_IN
-;        jnz     .checksum_ok
+        jnz     .checksum_ok
         push    ecx esi
         pop     edx ecx
         jne     .drop_no_socket
   .checksum_ok:
+; Verify the data offset
-; Verify the data offset
+        movzx   eax, [edx + TCP_header.DataOffset]
-        and     [edx + TCP_header.DataOffset], 0xf0                     ; Calculate TCP segment header size (throwing away unused reserved bits in TCP header)
+        and     al, 0xf0                        ; Calculate TCP segment header size (throwing away unused reserved bits in TCP header)
-        shr     [edx + TCP_header.DataOffset], 2
+        shr     al, 2
-        cmp     [edx + TCP_header.DataOffset], sizeof.TCP_header        ; Now see if it's at least the size of a standard TCP header
+        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
-        jb      .drop_no_socket                                         ; If not, drop the packet
         mov     [dataoffset], eax
         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: socket locked\n"
 ;---------------------------
 ; disable all temporary bits
-        mov     [ebx + TCP_SOCKET.temp_bits], 0
+        mov     [temp_bits], 0
         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?
+        mov     [temp_bits], TCP_BIT_DROPSOCKET
         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
-; Process TCP options
+;;;        jz      .not_uni_xfer                           ; also no header prediction
         push    ecx
-        movzx   ecx, [edx + TCP_header.DataOffset]
+        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"
         cmp     ecx, sizeof.TCP_header                  ; Does header contain any options?
-;;; FIXME: for LISTEN, options should be called after we determined route, we need it for MSS
+        je      .no_options
 ;;;        cmp     [ebx + TCP_SOCKET.t_state], TCPS_LISTEN ; no options when in listen state
-;;;        jz      .not_uni_xfer                           ; also no header prediction
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Segment has options\n"
         jne     .no_options                     ; error occured, ignore all options!
         test    [edx + TCP_header.Flags], TH_SYN
+        jz      @f
         jz      @f
         xor     eax, eax
         lodsw
         rol     ax, 8
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Maxseg=%u\n", ax
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Maxseg=%u\n", eax
         call    TCP_mss
         jz      @f
         or      [ebx + TCP_SOCKET.t_flags], TF_RCVD_TSTMP
        @@:
+        lodsd
-        lodsd
+        bswap   eax
         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
+        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]
-        jge     .no_paws
+        jbe     .no_paws
         DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: PAWS: detected an old segment\n"
         call    SOCKET_ring_free
         popa
 ; Update RTT estimators
-        test    [ebx + TCP_SOCKET.temp_bits], TCP_BIT_TIMESTAMP
+        test    [temp_bits], TCP_BIT_TIMESTAMP
         jz      .no_timestamp_rtt
-        mov     eax, [esp + 4]                          ; timestamp when this segment was received
+        mov     eax, [timestamp]
         sub     eax, [ebx + TCP_SOCKET.ts_ecr]
         inc     eax
 ; 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
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Header prediction: we are receiving %u bytes\n", ecx
-        movzx   esi, [edx + TCP_header.DataOffset]
+        mov     esi, [dataoffset]
+        add     esi, edx
-        add     esi, edx
+        lea     eax, [ebx + STREAM_SOCKET.rcv]
-        lea     eax, [ebx + STREAM_SOCKET.rcv]
+        call    SOCKET_ring_write                       ; Add the data to the socket buffer
-        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
   .not_uni_xfer:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Header prediction failed\n"
 ; Calculate receive window size
+; Calculate receive window size
         push    edx
+        mov     eax, SOCKET_MAXDATA
-        mov     eax, SOCKETBUFFSIZE
+        sub     eax, [ebx + STREAM_SOCKET.rcv.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]
-        mov     edx, [ebx + TCP_SOCKET.RCV_ADV]
+        sub     edx, [ebx + TCP_SOCKET.RCV_NXT]
-        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
         je      .SYN_SENT
 ;----------------------------
 ; trim any data not in window
 ; 1. Check for duplicate data at beginning of segment
 ; check for duplicate data at beginning of segment (635)
 ; Calculate number of bytes we need to drop
         mov     eax, [ebx + TCP_SOCKET.RCV_NXT]
         and     [edx + TCP_header.Flags], not (TH_URG)
   .dup_syn:
         dec     eax
   .no_dup_syn:
-; Check for entire duplicate segment (646)
+; 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
 ; 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"
+; But keep on processing for RST or ACK
         or      [ebx + TCP_SOCKET.t_flags], TF_ACKNOW
+        mov     eax, ecx
-        mov     eax, ecx
-;TODO: update stats
+;;; TODO: update stats
 ;-----------------------------------------------
+; Remove duplicate data and update urgent offset
+  .duplicate:
-; Remove duplicate data and update urgent offset
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: trimming duplicate data\n"
-  .duplicate:
+; Trim data from left side of window
-;;; TODO: 677
+        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 (687)
+; Handle data that arrives after process terminates
   .no_duplicate:
         call    TCP_close
-;;;TODO: update stats
+;;; TODO: update stats
         jmp     .respond_seg_reset
 ;----------------------------------------
-; Remove data beyond right edge of window (700-736)
+; Remove data beyond right edge of window
   .not_terminated:
         mov     eax, [edx + TCP_header.SequenceNumber]
         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
+; 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     eax, [edx + TCP_header.SequenceNumber]
+        mov     esi, [edx + TCP_header.SequenceNumber]
-        cmp     eax, [ebx + TCP_SOCKET.RCV_NXT]
-        jne     .drop_after_ack
+        cmp     esi, [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
+        or      [ebx + TCP_SOCKET.t_flags], TF_ACKNOW
-        jmp     .no_excess_data
+;;; TODO: update stats
-  .dont_drop_all:
-;;; TODO: update stats
+  .dont_drop_all:
-;;; TODO: 733
+;;; TODO: update stats
         DEBUGF  DEBUG_NETWORK_VERBOSE, "Trimming %u bytes from the right of the window\n"
-        sub     ecx, eax
+        sub     ecx, eax        ; remove data from the right side of window (decrease data length)
-        and     [ebx + TCP_SOCKET.t_flags], not (TH_PUSH or TH_FIN)
+        and     [edx + TCP_header.Flags], not (TH_PUSH or TH_FIN)
   .no_excess_data:
 ;-----------------
-; Record timestamp (737-746)
+; Record timestamp
 ; If last ACK falls within this segments sequence numbers, record its timestamp
-        test    [ebx + TCP_SOCKET.temp_bits], TCP_BIT_TIMESTAMP
+        test    [temp_bits], TCP_BIT_TIMESTAMP
         sub     eax, ecx
         jae     .no_timestamp
         DEBUGF  DEBUG_NETWORK_VERBOSE, "Recording timestamp\n"
-        mov     eax, [esp + 4]                                  ; tcp_now
+        mov     eax, [timestamp]
         mov     [ebx + TCP_SOCKET.ts_recent_age], eax
         mov     eax, [ebx + TCP_SOCKET.ts_val]
         push    [ebx + TCP_SOCKET.SND_NXT]              ; >>>>
+        mov     eax, [ebx + TCP_SOCKET.SND_WND]
-        mov     eax, [ebx + TCP_SOCKET.SND_WND]
+        cmp     eax, [ebx + TCP_SOCKET.SND_CWND]
+        jbe     @f
-        cmp     eax, [ebx + TCP_SOCKET.SND_CWND]
+        mov     eax, [ebx + TCP_SOCKET.SND_CWND]
-        cmova   eax, [ebx + TCP_SOCKET.SND_CWND]
+  @@:
         shr     eax, 1
         push    edx
         xor     edx, edx
         ;;; TODO: update stats
         DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: acceptable ACK for %u bytes\n", edi
 ;------------------------------------------
-; RTT measurements and retransmission timer  (912-926)
+; RTT measurements and retransmission timer
 ; If we have a timestamp, update smoothed RTT
-        test    [ebx + TCP_SOCKET.temp_bits], TCP_BIT_TIMESTAMP
+        test    [temp_bits], TCP_BIT_TIMESTAMP
         jz      .timestamp_not_present
-        mov     eax, [esp+4]
+        mov     eax, [timestamp]
         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
+        or      [temp_bits], TCP_BIT_NEEDOUTPUT
         jmp     .no_restart
   .more_data:
         test    [ebx + TCP_SOCKET.timer_flags], timer_flag_persist
         mov     eax, TCP_max_win
         shl     eax, cl
         pop     ecx
+        cmp     esi, eax
-        cmp     esi, eax
+        jbe     @f
+        mov     esi, eax
-        cmova   esi, eax
+  @@:
         mov     [ebx + TCP_SOCKET.SND_CWND], esi
         push    ebx
         lea     ecx, [ebx + SOCKET.mutex]
         call    mutex_unlock
         pop     ebx
         push    ebx
         mov     eax, ebx
-        call    TCP_disconnect
-        pop     ebx
+        call    TCP_close
-        jmp     .destroy_new_socket
+        jmp     .drop_no_socket
   .ack_tw:
         mov     [ebx + TCP_SOCKET.timer_timed_wait], 2 * TCP_time_MSL
         TCP_sendseqinit ebx
         TCP_rcvseqinit ebx
         mov     [ebx + TCP_SOCKET.t_state], TCPS_SYN_RECEIVED
-        mov     [ebx + TCP_SOCKET.t_flags], TF_ACKNOW
+        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
         lea     eax, [ebx + STREAM_SOCKET.rcv]
         call    SOCKET_ring_create
   .trim_then_step6:
+        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)
-        inc     [edx + TCP_header.SequenceNumber]
+;;; TODO: update stats
-;;; TODO: Drop any received data that follows receive window (590)
+  .dont_trim:
         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
+        or      [temp_bits], TCP_BIT_NEEDOUTPUT
 ; 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]
+        mov     esi, [dataoffset]
         add     esi, edx
         lea     eax, [ebx + STREAM_SOCKET.rcv]
         call    SOCKET_ring_write                       ; Add the data to the socket buffer
         call    SOCKET_notify
         jmp     .data_done
-  .out_of_order:
+  .out_of_order:
         DEBUGF  DEBUG_NETWORK_VERBOSE,  "TCP data is out of order!\nSequencenumber is %u, we expected %u.\n", \
-        DEBUGF  DEBUG_NETWORK_VERBOSE,  "TCP data is out of order\n"
+        [edx + TCP_header.SequenceNumber], [ebx + TCP_SOCKET.RCV_NXT]
+; Uh-oh, some data is out of order, lets call TCP reassemble for help
 ; Uh-oh, some data is out of order, lets call TCP reassemble for help
         call    TCP_reassemble
-        DEBUGF  DEBUG_NETWORK_VERBOSE,  "1470\n"
+; Generate ACK immediately, to let the other end know that a segment was received out of order,
         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
+        or      [ebx + TCP_SOCKET.t_flags], TF_ACKNOW
         inc     [ebx + TCP_SOCKET.RCV_NXT]
         dd      .final_processing       ; TCPS_LAST_ACK
         dd      .fin_wait2              ; TCPS_FIN_WAIT_2
         dd      .fin_timed              ; TCPS_TIMED_WAIT
-  .fin_syn_est:
   .fin_syn_est:
         mov     [ebx + TCP_SOCKET.t_state], TCPS_CLOSE_WAIT
         jmp     .final_processing
   .fin_wait1:
   .fin_wait1:
         mov     [ebx + TCP_SOCKET.t_state], TCPS_CLOSING
-        jmp     .final_processing
         jmp     .final_processing
   .fin_wait2:
   .fin_wait2:
-        mov     [ebx + TCP_SOCKET.t_state], TCPS_TIMED_WAIT
-        mov     eax, ebx
-        call    TCP_cancel_timers
+        mov     [ebx + TCP_SOCKET.t_state], TCPS_TIMED_WAIT
-        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
+        call    TCP_cancel_timers
-        jmp     .final_processing
+        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      .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    NET_packet_free
+        jmp     .loop
   .fin_timed:
         mov     [ebx + TCP_SOCKET.timer_timed_wait], 2 * TCP_time_MSL
         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    NET_packet_free
-        add     esp, 4
-        jmp     .loop
+        jmp     .dumpit
 ;---------
 ; Respond
         lea     ecx, [ebx + SOCKET.mutex]
         call    mutex_unlock
         popa
   .destroy_new_socket:
-        test    [ebx + TCP_SOCKET.temp_bits], TCP_BIT_DROPSOCKET
+        test    [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"
+  .drop_no_socket:
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Drop (no socket)\n"

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/network/tcp_input.inc – Rev 3908 → 4423