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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2017. All rights reserved.    ;;
;; Distributed under terms of the GNU General Public License       ;;
;;                                                                 ;;
;;  Part of the TCP/IP network stack for KolibriOS                 ;;
;;                                                                 ;;
;;   Written by hidnplayr@kolibrios.org                            ;;
;;                                                                 ;;
;;    Based on the code of 4.4BSD                                  ;;
;;                                                                 ;;
;;          GNU GENERAL PUBLIC LICENSE                             ;;
;;             Version 2, June 1991                                ;;
;;                                                                 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 6916 $
 
TCP_BIT_SENDALOT        = 1 shl 0
 
;-----------------------------------------------------------------;
;                                                                 ;
; tcp_output                                                      ;
;                                                                 ;
;  IN:  eax = socket pointer                                      ;
;                                                                 ;
; OUT:  eax = 0 on success/errorcode                              ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
proc tcp_output
 
locals
        temp_bits       db ?
        window          dd ?
endl
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_output: socket=%x state=%u\n", eax, [eax + TCP_SOCKET.t_state]
 
        push    eax
        lea     ecx, [eax + SOCKET.mutex]
        call    mutex_lock
        pop     eax
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_output: socket locked\n"
 
; We'll detect the length of the data to be transmitted, and flags to be used
; If there is some data, or any critical controls to send (SYN / RST), then transmit
; Otherwise, investigate further
 
        mov     ebx, [eax + TCP_SOCKET.SND_MAX]
        cmp     ebx, [eax + TCP_SOCKET.SND_UNA]
        jbe     .not_idle
 
        mov     ebx, [eax + TCP_SOCKET.t_idle]
        cmp     ebx, [eax + TCP_SOCKET.t_rxtcur]
        jbe     .not_idle
 
; We have been idle for a while and no ACKS are expected to clock out any data we send..
; Slow start to get ack "clock" running again.
 
        mov     ebx, [eax + TCP_SOCKET.t_maxseg]
        mov     [eax + TCP_SOCKET.SND_CWND], ebx
 
  .not_idle:
  .again:
        mov     [temp_bits], 0
 
; Calculate offset
 
        mov     ebx, [eax + TCP_SOCKET.SND_NXT]
        sub     ebx, [eax + TCP_SOCKET.SND_UNA]
 
; Determine window
 
        mov     ecx, [eax + TCP_SOCKET.SND_WND]
        cmp     ecx, [eax + TCP_SOCKET.SND_CWND]
        jb      @f
        mov     ecx, [eax + TCP_SOCKET.SND_CWND]
       @@:
 
; get flags in dl
 
        call    tcp_outflags
 
;------------------------
; data being forced out ?
 
; If in persist timeout with window of 0, send 1 byte.
; Otherwise, if window is small but nonzero, and timer expired,
; we will send what we can and go to transmit state
 
        test    [eax + TCP_SOCKET.t_flags], TF_FORCE
        jz      .no_force
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_output: forcing data out\n"
 
        test    ecx, ecx
        jnz     .no_zero_window
 
        cmp     ebx, [eax + STREAM_SOCKET.snd.size]
        jae     @f
        and     dl, not (TH_FIN)
       @@:
 
        inc     ecx
        jmp     .no_force
 
  .no_zero_window:
        and     [eax + TCP_SOCKET.timer_flags], not timer_flag_persist
        mov     [eax + TCP_SOCKET.t_rxtshift], 0
 
  .no_force:
 
;--------------------------------
; Calculate how much data to send
 
        mov     esi, [eax + STREAM_SOCKET.snd.size]
        cmp     esi, ecx
        jb      @f
        mov     esi, ecx
       @@:
        sub     esi, ebx
 
;------------------------
; check for window shrink
 
; If FIN has been sent, but not ACKed, but we havent been called to retransmit, esi will be -1
; Otherwise, window shrank after we sent into it.
 
        jae     .not_persist
 
; enter persist state
 
        xor     esi, esi
 
; If window shrank to 0
 
        test    ecx, ecx
        jnz     @f
 
; cancel pending retransmit
 
        and     [eax + TCP_SOCKET.timer_flags], not timer_flag_retransmission
 
; pull SND_NXT back to (closed) window, We will enter persist state below.
 
        push    [eax + TCP_SOCKET.SND_UNA]
        pop     [eax + TCP_SOCKET.SND_NXT]
       @@:
 
; If window didn't close completely, just wait for an ACK
 
  .not_persist:
 
;---------------------------
; Send one segment at a time
 
        cmp     esi, [eax + TCP_SOCKET.t_maxseg]
        jbe     @f
        mov     esi, [eax + TCP_SOCKET.t_maxseg]
        or      [temp_bits], TCP_BIT_SENDALOT
       @@:
 
;--------------------------------------------
; Turn of FIN flag if send buffer not emptied
 
        mov     edi, [eax + TCP_SOCKET.SND_NXT]
        add     edi, esi
        sub     edi, [eax + TCP_SOCKET.SND_UNA]
        cmp     edi, [eax + STREAM_SOCKET.snd.size]
        jae     @f
        and     dl, not (TH_FIN)
       @@:
 
;-------------------------------
; calculate window advertisement
 
        mov     ecx, SOCKET_BUFFER_SIZE
        sub     ecx, [eax + STREAM_SOCKET.rcv.size]
 
;------------------------------
; Sender silly window avoidance
 
        test    esi, esi
        jz      .len_zero
 
        cmp     esi, [eax + TCP_SOCKET.t_maxseg]
        je      .send
 
        add     ebx, esi                                ; offset + length
        cmp     ebx, [eax + STREAM_SOCKET.snd.size]
        jb      @f
 
        test    [eax + TCP_SOCKET.t_flags], TF_NODELAY
        jnz     .send
 
        mov     ebx, [eax + TCP_SOCKET.SND_MAX]
        cmp     ebx, [eax + TCP_SOCKET.SND_UNA]
        je      .send
       @@:
 
        test    [eax + TCP_SOCKET.t_flags], TF_FORCE
        jnz     .send
 
        mov     ebx, [eax + TCP_SOCKET.max_sndwnd]
        shr     ebx, 1
        cmp     esi, ebx
        jae     .send
 
        mov     ebx, [eax + TCP_SOCKET.SND_NXT]
        cmp     ebx, [eax + TCP_SOCKET.SND_MAX]
        jb      .send
 
  .len_zero:
 
;----------------------------------------
; Check if a window update should be sent
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_output: window=%d\n", ecx
 
; Compare available window to amount of window known to peer (as advertised window less next expected input)
; If the difference is at least two max size segments, or at least 50% of the maximum possible window,
; Then we want to send a window update to the peer.
 
        test    ecx, ecx
        jz      .no_window
 
        push    ecx
        mov     cl, [eax + TCP_SOCKET.RCV_SCALE]
        mov     ebx, TCP_max_win
        shl     ebx, cl
        pop     ecx
 
        cmp     ebx, ecx
        jb      @f
        mov     ebx, ecx
       @@:
        sub     ebx, [eax + TCP_SOCKET.RCV_ADV]
        add     ebx, [eax + TCP_SOCKET.RCV_NXT]
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_output: we can increase window by %d bytes\n", ebx
 
        mov     edi, [eax + TCP_SOCKET.t_maxseg]
        shl     edi, 1
        cmp     ebx, edi
        jae     .send
 
        shl     ebx, 1
;        cmp     ebx, [eax + TCP_SOCKET.]    ;;; TODO: check with receive buffer high water mark
;        jae     TCP_send
 
  .no_window:
 
;--------------------------
; Should a segment be sent?
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_output: Should a segment be sent?\n"
 
        test    [eax + TCP_SOCKET.t_flags], TF_ACKNOW   ; we need to ACK
        jnz     .send
 
        test    dl, TH_SYN + TH_RST                     ; we need to send a SYN or RST
        jnz     .send
 
        mov     ebx, [eax + TCP_SOCKET.SND_UP]          ; when urgent pointer is beyond start of send bufer
        cmp     ebx, [eax + TCP_SOCKET.SND_UNA]
        ja      .send
 
; Do we need to send a FIN according to our state?
 
        test    dl, TH_FIN
        jz      .enter_persist                          ; no reason to send, enter persist state
 
; Do so if we didnt do it already
 
        test    [eax + TCP_SOCKET.t_flags], TF_SENTFIN
        jz      .send
 
; Or when we need to retransmit the FIN
 
        mov     ebx, [eax + TCP_SOCKET.SND_NXT]
        cmp     ebx, [eax + TCP_SOCKET.SND_UNA]
        je      .send
 
;--------------------
; Enter persist state
 
  .enter_persist:
 
        cmp     [eax + STREAM_SOCKET.snd.size], 0                       ; Data ready to send?
        jne     @f
        and     [eax + TCP_SOCKET.timer_flags], not timer_flag_retransmission
        jne     @f
 
        test    [eax + TCP_SOCKET.timer_flags], timer_flag_persist      ; Persist timer already expired?
        jnz     @f
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_output: Entering persist state\n"
 
        mov     [eax + TCP_SOCKET.t_rxtshift], 0
        call    tcp_set_persist
       @@:
 
;----------------------------
; No reason to send a segment
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_output: No reason to send a segment\n"
 
        pusha
        lea     ecx, [eax + SOCKET.mutex]
        call    mutex_unlock
        popa
 
        xor     eax, eax
        ret
 
 
;-----------------------------------------------
;
; Send a segment
;
; eax = socket pointer
; esi = data len
;  dl = flags
;
;-----------------------------------------------
  .send:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_send: socket=%x length=%u flags=%x\n", eax, esi, dl
 
        push    eax                     ; save socket ptr
        push    esi                     ; and data length too
        mov     edi, sizeof.TCP_header  ; edi will contain headersize
 
;------------------------------------
; Send options with first SYN segment
 
        test    dl, TH_SYN
        jz      .options_done
 
        push    [eax + TCP_SOCKET.ISS]
        pop     [eax + TCP_SOCKET.SND_NXT]
 
        test    [eax + TCP_SOCKET.t_flags], TF_NOOPT
        jnz     .options_done
 
        mov     ecx, 1460                              ;;;; FIXME: use routing blablabla to determine MSS
        or      ecx, TCP_OPT_MAXSEG shl 24 + 4 shl 16
        bswap   ecx
        push    ecx
        add     di, 4
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_send: added maxseg option\n"
 
        test    [eax + TCP_SOCKET.t_flags], TF_REQ_SCALE
        jz      .no_scale
 
        test    dl, TH_ACK
        jz      .scale_opt
 
        test    [eax + TCP_SOCKET.t_flags], TF_RCVD_SCALE
        jz      .no_scale
 
  .scale_opt:
        mov     cl, [eax + TCP_SOCKET.request_r_scale]
        mov     ch, TCP_OPT_NOP
        pushw   cx
        pushw   TCP_OPT_WINDOW + 3 shl 8
        add     di, 4
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_send: added scale option\n"
 
  .no_scale:
  .no_syn:
 
;------------------------------------
; Make the timestamp option if needed
 
        test    [eax + TCP_SOCKET.t_flags], TF_REQ_TSTMP
        jz      .no_timestamp
 
        test    dl, TH_RST
        jnz     .no_timestamp
 
        test    dl, TH_ACK
        jz      .timestamp
 
        test    [eax + TCP_SOCKET.t_flags], TF_RCVD_TSTMP
        jz      .no_timestamp
 
  .timestamp:
        pushd   0
        pushd   [timer_ticks]
        pushd   TCP_OPT_NOP + TCP_OPT_NOP shl 8 + TCP_OPT_TIMESTAMP shl 16 + 10 shl 24
        add     di, 12
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_send: added timestamp\n"
 
  .no_timestamp:
 
        ; 
 
  .options_done:
 
; eax = socket ptr
; edx = flags
; edi = header size
; esi = data len
 
;---------------------------------------------
; check if we dont exceed the max segment size
 
        add     esi, edi                        ; total TCP segment size
        cmp     esi, [eax + TCP_SOCKET.t_maxseg]
        jbe     .no_overflow
 
        mov     esi, [eax + TCP_SOCKET.t_maxseg]
        or      [temp_bits], TCP_BIT_SENDALOT
  .no_overflow:
 
; Update stats
 
        test    esi, esi
        jz      .zero_data
 
        test    [eax + TCP_SOCKET.t_flags], TF_FORCE
        jz      @f
        cmp     esi, 1
        jne     @f
        inc     [TCPS_sndprobe]
        jmp     .eos
  @@:
 
        mov     ebx, [eax + TCP_SOCKET.SND_NXT]
        cmp     ebx, [eax + TCP_SOCKET.SND_MAX]
        jae     @f
        inc     [TCPS_sndrexmitpack]
        add     [TCPS_sndrexmitbyte], esi
        jmp     .eos
  @@:
        inc     [TCPS_sndpack]
        add     [TCPS_sndbyte], esi
        jmp     .eos
 
  .zero_data:
        test    [eax + TCP_SOCKET.t_flags], TF_ACKNOW
        jz      @f
        inc     [TCPS_sndacks]
        jmp     .eos
  @@:
        test    dl, TH_SYN + TH_FIN + TH_RST
        jz      @f
        inc     [TCPS_sndctrl]
        jmp     .eos
  @@:
        mov     ebx, [eax + TCP_SOCKET.SND_UP]
        cmp     ebx, [eax + TCP_SOCKET.SND_UNA]
        jb      @f
        inc     [TCPS_sndurg]
        jmp     .eos
  @@:
        inc     [TCPS_sndwinup]
 
  .eos:
 
;---------------------------------------------------
; Dont increase sequence number when resending a FIN
 
        test    dl, TH_FIN
        jz      .no_fin_retransmit
 
        test    [eax + TCP_SOCKET.t_flags], TF_SENTFIN
        jz      .no_fin_retransmit
 
        mov     ebx, [eax + TCP_SOCKET.SND_NXT]
        cmp     ebx, [eax + TCP_SOCKET.SND_MAX]
        jne     .no_fin_retransmit
 
        dec     [eax + TCP_SOCKET.SND_NXT]
 
  .no_fin_retransmit:
 
;----------------------------------------------------
; Calculate the receive window.
; Dont shrink window, but avoid silly window syndrome
 
        mov     ebx, SOCKET_BUFFER_SIZE
        sub     ebx, [eax + STREAM_SOCKET.rcv.size]
 
        cmp     ebx, SOCKET_BUFFER_SIZE/4
        jae     @f
        cmp     ebx, [eax + TCP_SOCKET.t_maxseg]
        jae     @f
        xor     ebx, ebx
  @@:
 
        cmp     ebx, TCP_max_win
        jbe     @f
        mov     ebx, TCP_max_win
  @@:
 
        mov     ecx, [eax + TCP_SOCKET.RCV_ADV]
        sub     ecx, [eax + TCP_SOCKET.RCV_NXT]
        cmp     ebx, ecx
        jg      @f
        mov     ebx, ecx
  @@:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_send: window=%u\n", ebx
        mov     [window], ebx
 
        mov     cl, [eax + TCP_SOCKET.RCV_SCALE]
        shr     ebx, cl
        xchg    bl, bh
 
;-----------------------------------------------------------------
; Start by pushing all TCP header values in reverse order on stack
; (essentially, creating the tcp header on the stack!)
 
        pushw   0                               ; UrgentPointer
        pushw   0                               ; Checksum
        pushw   bx                              ; Window
        shl     edi, 2                          ; DataOffset
        shl     dx, 8
        or      dx, di                          ; Flags
        pushw   dx
        shr     edi, 2                          ; DataOffset
 
        push    [eax + TCP_SOCKET.RCV_NXT]      ; AckNumber
        ntohd   [esp]
 
        push    [eax + TCP_SOCKET.SND_NXT]      ; SequenceNumber
        ntohd   [esp]
 
        push    [eax + TCP_SOCKET.RemotePort]   ; DestinationPort
        push    [eax + TCP_SOCKET.LocalPort]    ; SourcePort
 
        push    edi                             ; header size
 
;---------------------
; Create the IP packet
 
        mov     ecx, esi
        mov     ebx, [eax + IP_SOCKET.device]
        mov     edx, [eax + IP_SOCKET.LocalIP]  ; source ip
        mov     edi, [eax + IP_SOCKET.RemoteIP] ; dest ip
        mov     al, [eax + IP_SOCKET.ttl]
        mov     ah, IP_PROTO_TCP
        call    ipv4_output
        jz      .ip_error
 
;------------------------------------------
; Move TCP header from stack to TCP segment
 
        push    ecx
        mov     ecx, [esp + 4]
        lea     esi, [esp + 8]
        shr     ecx, 2                          ; count is in bytes, we will work with dwords
        rep movsd
        pop     ecx                             ; full TCP packet size
 
        pop     esi                             ; headersize
        add     esp, esi                        ; remove it from stack
 
        push    eax                             ; packet ptr for send proc
 
        mov     edx, edi                        ; begin of data
        sub     edx, esi                        ; begin of packet (edi = begin of data)
        push    ecx
        sub     ecx, esi                        ; data size
 
;--------------
; Copy the data
 
; eax = ptr to ring struct
; ecx = buffer size
; edi = ptr to buffer
 
        mov     eax, [esp + 12]                 ; get socket ptr
 
        push    edx
        push    [eax + TCP_SOCKET.SND_NXT]      ; we'll need this for timing the transmission
        test    ecx, ecx
        jz      .nodata
        mov     edx, [eax + TCP_SOCKET.SND_NXT]
        add     [eax + TCP_SOCKET.SND_NXT], ecx ; update sequence number
        sub     edx, [eax + TCP_SOCKET.SND_UNA] ; offset
        add     eax, STREAM_SOCKET.snd
        call    socket_ring_read
  .nodata:
        pop     edi
        pop     esi                             ; begin of data
        pop     ecx                             ; full packet size
        mov     eax, [esp + 8]                  ; socket ptr
 
;----------------------------
; initialize retransmit timer
 
;TODO: check t_force and persist
 
        test    [esi + TCP_header.Flags], TH_SYN + TH_FIN       ; syn and fin take a sequence number
        jz      @f
        inc     [eax + TCP_SOCKET.SND_NXT]
        test    [esi + TCP_header.Flags], TH_FIN
        jz      @f
        or      [eax + TCP_SOCKET.t_flags], TF_SENTFIN          ; if we sent a fin, set the sentfin flag
       @@:
 
        mov     edx, [eax + TCP_SOCKET.SND_NXT]
        cmp     edx, [eax + TCP_SOCKET.SND_MAX]                 ; is this a retransmission?
        jbe     @f
        mov     [eax + TCP_SOCKET.SND_MAX], edx                 ; [eax + TCP_SOCKET.SND_NXT] from before we updated it
 
        cmp     [eax + TCP_SOCKET.t_rtt], 0                     ; are we currently timing anything?
        je      @f
        mov     [eax + TCP_SOCKET.t_rtt], 1                     ; nope, start transmission timer
        mov     [eax + TCP_SOCKET.t_rtseq], edi
        inc     [TCPS_segstimed]
       @@:
 
; set retransmission timer if not already set, and not doing an ACK or keepalive probe
 
        test    [eax + TCP_SOCKET.timer_flags], timer_flag_retransmission
        jnz     .retransmit_set
 
        cmp     edx, [eax + TCP_SOCKET.SND_UNA]                 ; edx is still [eax + TCP_SOCKET.SND_NXT]
        je      .retransmit_set
 
        mov     edx, [eax + TCP_SOCKET.t_rxtcur]
        mov     [eax + TCP_SOCKET.timer_retransmission], edx
        or      [eax + TCP_SOCKET.timer_flags], timer_flag_retransmission
 
        test    [eax + TCP_SOCKET.timer_flags], timer_flag_persist
        jz      .retransmit_set
        and     [eax + TCP_SOCKET.timer_flags], not timer_flag_persist
        mov     [eax + TCP_SOCKET.t_rxtshift], 0
  .retransmit_set:
 
;--------------------
; Create the checksum
 
        xor     dx, dx
        test    [ebx + NET_DEVICE.hwacc], NET_HWACC_TCP_IPv4_OUT
        jnz     .checksum_ok
 
        tcp_checksum (eax + IP_SOCKET.LocalIP), (eax + IP_SOCKET.RemoteIP)
 
  .checksum_ok:
        mov     [esi + TCP_header.Checksum], dx
 
;----------------
; Send the packet
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_send: Sending with device %x\n", ebx
        call    [ebx + NET_DEVICE.transmit]
        jnz     .send_error
 
;---------------
; Ok, data sent!
 
        pop     ecx
        pop     eax
 
        call    net_ptr_to_num4
        inc     [TCP_segments_tx + edi]
        inc     [TCPS_sndtotal]
 
; update advertised receive window
 
        mov     ecx, [window]
        test    ecx, ecx
        jz      @f
        add     ecx, [eax + TCP_SOCKET.RCV_NXT]
        cmp     ecx, [eax + TCP_SOCKET.RCV_ADV]
        jbe     @f
        mov     [eax + TCP_SOCKET.RCV_ADV], ecx
       @@:
 
; update last ack sent
 
        push    [eax + TCP_SOCKET.RCV_NXT]
        pop     [eax + TCP_SOCKET.last_ack_sent]
 
; clear the ACK flags
 
        and     [eax + TCP_SOCKET.t_flags], not (TF_ACKNOW + TF_DELACK)
 
;--------------
; unlock socket
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_send: unlocking socket 0x%x\n", eax
 
        push    eax
        lea     ecx, [eax + SOCKET.mutex]
        call    mutex_unlock
        pop     eax
 
;-----------------------------
; Check if we need more output
 
        test    [temp_bits], TCP_BIT_SENDALOT
        jnz     tcp_output.again
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_send: success!\n"
 
        xor     eax, eax
        ret
 
 
  .ip_error:
        pop     ecx
        add     esp, ecx
        add     esp, 4
        pop     eax
 
        mov     [eax + TCP_SOCKET.timer_retransmission], TCP_time_re_min
        or      [eax + TCP_SOCKET.timer_flags], timer_flag_retransmission
 
        lea     ecx, [eax + SOCKET.mutex]
        call    mutex_unlock
 
        DEBUGF  DEBUG_NETWORK_ERROR, "TCP_send: IP error\n"
 
        or      eax, -1
        ret
 
 
  .send_error:
        add     esp, 4
        pop     eax
 
        lea     ecx, [eax + SOCKET.mutex]
        call    mutex_unlock
 
        DEBUGF  DEBUG_NETWORK_ERROR, "TCP_send: sending failed\n"
 
        or      eax, -2
        ret
 
 
endp

Rev 6914	Rev 6916
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2017. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2017. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;; Part of the TCP/IP network stack for KolibriOS ;;	6	;; Part of the TCP/IP network stack for KolibriOS ;;
7	;; ;;	7	;; ;;
8	;; Written by hidnplayr@kolibrios.org ;;	8	;; Written by hidnplayr@kolibrios.org ;;
9	;; ;;	9	;; ;;
10	;; Based on the code of 4.4BSD ;;	10	;; Based on the code of 4.4BSD ;;
11	;; ;;	11	;; ;;
12	;; GNU GENERAL PUBLIC LICENSE ;;	12	;; GNU GENERAL PUBLIC LICENSE ;;
13	;; Version 2, June 1991 ;;	13	;; Version 2, June 1991 ;;
14	;; ;;	14	;; ;;
15	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	15	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
16		16
17	$Revision: 6914 $	17	$Revision: 6916 $
18		18
19	TCP_BIT_SENDALOT = 1 shl 0	19	TCP_BIT_SENDALOT = 1 shl 0
20		20
21	;-----------------------------------------------------------------;	21	;-----------------------------------------------------------------;
22	; ;	22	; ;
23	; tcp_output ;	23	; tcp_output ;
24	; ;	24	; ;
25	; IN: eax = socket pointer ;	25	; IN: eax = socket pointer ;
26	; ;	26	; ;
27	; OUT: eax = 0 on success/errorcode ;	27	; OUT: eax = 0 on success/errorcode ;
28	; ;	28	; ;
29	;-----------------------------------------------------------------;	29	;-----------------------------------------------------------------;
30	align 4	30	align 4
31	proc tcp_output	31	proc tcp_output
32		32
33	locals	33	locals
34	temp_bits db ?	34	temp_bits db ?
35	window dd ?	35	window dd ?
36	endl	36	endl
37		37
38	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_output: socket=%x state=%u\n", eax, [eax + TCP_SOCKET.t_state]	38	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_output: socket=%x state=%u\n", eax, [eax + TCP_SOCKET.t_state]
39		39
40	push eax	40	push eax
41	lea ecx, [eax + SOCKET.mutex]	41	lea ecx, [eax + SOCKET.mutex]
42	call mutex_lock	42	call mutex_lock
43	pop eax	43	pop eax
44		44
45	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_output: socket locked\n"	45	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_output: socket locked\n"
46		46
47	; We'll detect the length of the data to be transmitted, and flags to be used	47	; We'll detect the length of the data to be transmitted, and flags to be used
48	; If there is some data, or any critical controls to send (SYN / RST), then transmit	48	; If there is some data, or any critical controls to send (SYN / RST), then transmit
49	; Otherwise, investigate further	49	; Otherwise, investigate further
50		50
51	mov ebx, [eax + TCP_SOCKET.SND_MAX]	51	mov ebx, [eax + TCP_SOCKET.SND_MAX]
52	cmp ebx, [eax + TCP_SOCKET.SND_UNA]	52	cmp ebx, [eax + TCP_SOCKET.SND_UNA]
53	jbe .not_idle	53	jbe .not_idle
54		54
55	mov ebx, [eax + TCP_SOCKET.t_idle]	55	mov ebx, [eax + TCP_SOCKET.t_idle]
56	cmp ebx, [eax + TCP_SOCKET.t_rxtcur]	56	cmp ebx, [eax + TCP_SOCKET.t_rxtcur]
57	jbe .not_idle	57	jbe .not_idle
58		58
59	; We have been idle for a while and no ACKS are expected to clock out any data we send..	59	; We have been idle for a while and no ACKS are expected to clock out any data we send..
60	; Slow start to get ack "clock" running again.	60	; Slow start to get ack "clock" running again.
61		61
62	mov ebx, [eax + TCP_SOCKET.t_maxseg]	62	mov ebx, [eax + TCP_SOCKET.t_maxseg]
63	mov [eax + TCP_SOCKET.SND_CWND], ebx	63	mov [eax + TCP_SOCKET.SND_CWND], ebx
64		64
65	.not_idle:	65	.not_idle:
66	.again:	66	.again:
67	mov [temp_bits], 0	67	mov [temp_bits], 0
68		68
69	; Calculate offset	69	; Calculate offset
70		70
71	mov ebx, [eax + TCP_SOCKET.SND_NXT]	71	mov ebx, [eax + TCP_SOCKET.SND_NXT]
72	sub ebx, [eax + TCP_SOCKET.SND_UNA]	72	sub ebx, [eax + TCP_SOCKET.SND_UNA]
73		73
74	; Determine window	74	; Determine window
75		75
76	mov ecx, [eax + TCP_SOCKET.SND_WND]	76	mov ecx, [eax + TCP_SOCKET.SND_WND]
77	cmp ecx, [eax + TCP_SOCKET.SND_CWND]	77	cmp ecx, [eax + TCP_SOCKET.SND_CWND]
78	jb @f	78	jb @f
79	mov ecx, [eax + TCP_SOCKET.SND_CWND]	79	mov ecx, [eax + TCP_SOCKET.SND_CWND]
80	@@:	80	@@:
81		81
82	; get flags in dl	82	; get flags in dl
83		83
84	call tcp_outflags	84	call tcp_outflags
85		85
86	;------------------------	86	;------------------------
87	; data being forced out ?	87	; data being forced out ?
88		88
89	; If in persist timeout with window of 0, send 1 byte.	89	; If in persist timeout with window of 0, send 1 byte.
90	; Otherwise, if window is small but nonzero, and timer expired,	90	; Otherwise, if window is small but nonzero, and timer expired,
91	; we will send what we can and go to transmit state	91	; we will send what we can and go to transmit state
92		92
93	cmp [eax + TCP_SOCKET.t_force], 0	93	test [eax + TCP_SOCKET.t_flags], TF_FORCE
94	je .no_force	94	jz .no_force
95		95
96	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_output: forcing data out\n"	96	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_output: forcing data out\n"
97		97
98	test ecx, ecx	98	test ecx, ecx
99	jnz .no_zero_window	99	jnz .no_zero_window
100		100
101	cmp ebx, [eax + STREAM_SOCKET.snd.size]	101	cmp ebx, [eax + STREAM_SOCKET.snd.size]
102	jae @f	102	jae @f
103	and dl, not (TH_FIN)	103	and dl, not (TH_FIN)
104	@@:	104	@@:
105		105
106	inc ecx	106	inc ecx
107	jmp .no_force	107	jmp .no_force
108		108
109	.no_zero_window:	109	.no_zero_window:
110	and [eax + TCP_SOCKET.timer_flags], not timer_flag_persist	110	and [eax + TCP_SOCKET.timer_flags], not timer_flag_persist
111	mov [eax + TCP_SOCKET.t_rxtshift], 0	111	mov [eax + TCP_SOCKET.t_rxtshift], 0
112		112
113	.no_force:	113	.no_force:
114		114
115	;--------------------------------	115	;--------------------------------
116	; Calculate how much data to send	116	; Calculate how much data to send
117		117
118	mov esi, [eax + STREAM_SOCKET.snd.size]	118	mov esi, [eax + STREAM_SOCKET.snd.size]
119	cmp esi, ecx	119	cmp esi, ecx
120	jb @f	120	jb @f
121	mov esi, ecx	121	mov esi, ecx
122	@@:	122	@@:
123	sub esi, ebx	123	sub esi, ebx
124		124
125	;------------------------	125	;------------------------
126	; check for window shrink	126	; check for window shrink
127		127
128	; If FIN has been sent, but not ACKed, but we havent been called to retransmit, esi will be -1	128	; If FIN has been sent, but not ACKed, but we havent been called to retransmit, esi will be -1
129	; Otherwise, window shrank after we sent into it.	129	; Otherwise, window shrank after we sent into it.
130		130
131	jae .not_persist	131	jae .not_persist
132		132
133	; enter persist state	133	; enter persist state
134		134
135	xor esi, esi	135	xor esi, esi
136		136
137	; If window shrank to 0	137	; If window shrank to 0
138		138
139	test ecx, ecx	139	test ecx, ecx
140	jnz @f	140	jnz @f
141		141
142	; cancel pending retransmit	142	; cancel pending retransmit
143		143
144	and [eax + TCP_SOCKET.timer_flags], not timer_flag_retransmission	144	and [eax + TCP_SOCKET.timer_flags], not timer_flag_retransmission
145		145
146	; pull SND_NXT back to (closed) window, We will enter persist state below.	146	; pull SND_NXT back to (closed) window, We will enter persist state below.
147		147
148	push [eax + TCP_SOCKET.SND_UNA]	148	push [eax + TCP_SOCKET.SND_UNA]
149	pop [eax + TCP_SOCKET.SND_NXT]	149	pop [eax + TCP_SOCKET.SND_NXT]
150	@@:	150	@@:
151		151
152	; If window didn't close completely, just wait for an ACK	152	; If window didn't close completely, just wait for an ACK
153		153
154	.not_persist:	154	.not_persist:
155		155
156	;---------------------------	156	;---------------------------
157	; Send one segment at a time	157	; Send one segment at a time
158		158
159	cmp esi, [eax + TCP_SOCKET.t_maxseg]	159	cmp esi, [eax + TCP_SOCKET.t_maxseg]
160	jbe @f	160	jbe @f
161	mov esi, [eax + TCP_SOCKET.t_maxseg]	161	mov esi, [eax + TCP_SOCKET.t_maxseg]
162	or [temp_bits], TCP_BIT_SENDALOT	162	or [temp_bits], TCP_BIT_SENDALOT
163	@@:	163	@@:
164		164
165	;--------------------------------------------	165	;--------------------------------------------
166	; Turn of FIN flag if send buffer not emptied	166	; Turn of FIN flag if send buffer not emptied
167		167
168	mov edi, [eax + TCP_SOCKET.SND_NXT]	168	mov edi, [eax + TCP_SOCKET.SND_NXT]
169	add edi, esi	169	add edi, esi
170	sub edi, [eax + TCP_SOCKET.SND_UNA]	170	sub edi, [eax + TCP_SOCKET.SND_UNA]
171	cmp edi, [eax + STREAM_SOCKET.snd.size]	171	cmp edi, [eax + STREAM_SOCKET.snd.size]
172	jae @f	172	jae @f
173	and dl, not (TH_FIN)	173	and dl, not (TH_FIN)
174	@@:	174	@@:
175		175
176	;-------------------------------	176	;-------------------------------
177	; calculate window advertisement	177	; calculate window advertisement
178		178
179	mov ecx, SOCKET_BUFFER_SIZE	179	mov ecx, SOCKET_BUFFER_SIZE
180	sub ecx, [eax + STREAM_SOCKET.rcv.size]	180	sub ecx, [eax + STREAM_SOCKET.rcv.size]
181		181
182	;------------------------------	182	;------------------------------
183	; Sender silly window avoidance	183	; Sender silly window avoidance
184		184
185	test esi, esi	185	test esi, esi
186	jz .len_zero	186	jz .len_zero
187		187
188	cmp esi, [eax + TCP_SOCKET.t_maxseg]	188	cmp esi, [eax + TCP_SOCKET.t_maxseg]
189	je .send	189	je .send
190		190
191	add ebx, esi ; offset + length	191	add ebx, esi ; offset + length
192	cmp ebx, [eax + STREAM_SOCKET.snd.size]	192	cmp ebx, [eax + STREAM_SOCKET.snd.size]
193	jb @f	193	jb @f
194		194
195	test [eax + TCP_SOCKET.t_flags], TF_NODELAY	195	test [eax + TCP_SOCKET.t_flags], TF_NODELAY
196	jnz .send	196	jnz .send
197		197
198	mov ebx, [eax + TCP_SOCKET.SND_MAX]	198	mov ebx, [eax + TCP_SOCKET.SND_MAX]
199	cmp ebx, [eax + TCP_SOCKET.SND_UNA]	199	cmp ebx, [eax + TCP_SOCKET.SND_UNA]
200	je .send	200	je .send
201	@@:	201	@@:
202		202
203	test [eax + TCP_SOCKET.t_force], -1 ;;;	203	test [eax + TCP_SOCKET.t_flags], TF_FORCE
204	jnz .send	204	jnz .send
205		205
206	mov ebx, [eax + TCP_SOCKET.max_sndwnd]	206	mov ebx, [eax + TCP_SOCKET.max_sndwnd]
207	shr ebx, 1	207	shr ebx, 1
208	cmp esi, ebx	208	cmp esi, ebx
209	jae .send	209	jae .send
210		210
211	mov ebx, [eax + TCP_SOCKET.SND_NXT]	211	mov ebx, [eax + TCP_SOCKET.SND_NXT]
212	cmp ebx, [eax + TCP_SOCKET.SND_MAX]	212	cmp ebx, [eax + TCP_SOCKET.SND_MAX]
213	jb .send	213	jb .send
214		214
215	.len_zero:	215	.len_zero:
216		216
217	;----------------------------------------	217	;----------------------------------------
218	; Check if a window update should be sent	218	; Check if a window update should be sent
219		219
220	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_output: window=%d\n", ecx	220	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_output: window=%d\n", ecx
221		221
222	; Compare available window to amount of window known to peer (as advertised window less next expected input)	222	; Compare available window to amount of window known to peer (as advertised window less next expected input)
223	; If the difference is at least two max size segments, or at least 50% of the maximum possible window,	223	; If the difference is at least two max size segments, or at least 50% of the maximum possible window,
224	; Then we want to send a window update to the peer.	224	; Then we want to send a window update to the peer.
225		225
226	test ecx, ecx	226	test ecx, ecx
227	jz .no_window	227	jz .no_window
228		228
229	push ecx	229	push ecx
230	mov cl, [eax + TCP_SOCKET.RCV_SCALE]	230	mov cl, [eax + TCP_SOCKET.RCV_SCALE]
231	mov ebx, TCP_max_win	231	mov ebx, TCP_max_win
232	shl ebx, cl	232	shl ebx, cl
233	pop ecx	233	pop ecx
234		234
235	cmp ebx, ecx	235	cmp ebx, ecx
236	jb @f	236	jb @f
237	mov ebx, ecx	237	mov ebx, ecx
238	@@:	238	@@:
239	sub ebx, [eax + TCP_SOCKET.RCV_ADV]	239	sub ebx, [eax + TCP_SOCKET.RCV_ADV]
240	add ebx, [eax + TCP_SOCKET.RCV_NXT]	240	add ebx, [eax + TCP_SOCKET.RCV_NXT]
241		241
242	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_output: we can increase window by %d bytes\n", ebx	242	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_output: we can increase window by %d bytes\n", ebx
243		243
244	mov edi, [eax + TCP_SOCKET.t_maxseg]	244	mov edi, [eax + TCP_SOCKET.t_maxseg]
245	shl edi, 1	245	shl edi, 1
246	cmp ebx, edi	246	cmp ebx, edi
247	jae .send	247	jae .send
248		248
249	shl ebx, 1	249	shl ebx, 1
250	; cmp ebx, [eax + TCP_SOCKET.] ;;; TODO: check with receive buffer high water mark	250	; cmp ebx, [eax + TCP_SOCKET.] ;;; TODO: check with receive buffer high water mark
251	; jae TCP_send	251	; jae TCP_send
252		252
253	.no_window:	253	.no_window:
254		254
255	;--------------------------	255	;--------------------------
256	; Should a segment be sent?	256	; Should a segment be sent?
257		257
258	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_output: Should a segment be sent?\n"	258	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_output: Should a segment be sent?\n"
259		259
260	test [eax + TCP_SOCKET.t_flags], TF_ACKNOW ; we need to ACK	260	test [eax + TCP_SOCKET.t_flags], TF_ACKNOW ; we need to ACK
261	jnz .send	261	jnz .send
262		262
263	test dl, TH_SYN + TH_RST ; we need to send a SYN or RST	263	test dl, TH_SYN + TH_RST ; we need to send a SYN or RST
264	jnz .send	264	jnz .send
265		265
266	mov ebx, [eax + TCP_SOCKET.SND_UP] ; when urgent pointer is beyond start of send bufer	266	mov ebx, [eax + TCP_SOCKET.SND_UP] ; when urgent pointer is beyond start of send bufer
267	cmp ebx, [eax + TCP_SOCKET.SND_UNA]	267	cmp ebx, [eax + TCP_SOCKET.SND_UNA]
268	ja .send	268	ja .send
269		269
270	; Do we need to send a FIN according to our state?	270	; Do we need to send a FIN according to our state?
271		271
272	test dl, TH_FIN	272	test dl, TH_FIN
273	jz .enter_persist ; no reason to send, enter persist state	273	jz .enter_persist ; no reason to send, enter persist state
274		274
275	; Do so if we didnt do it already	275	; Do so if we didnt do it already
276		276
277	test [eax + TCP_SOCKET.t_flags], TF_SENTFIN	277	test [eax + TCP_SOCKET.t_flags], TF_SENTFIN
278	jz .send	278	jz .send
279		279
280	; Or when we need to retransmit the FIN	280	; Or when we need to retransmit the FIN
281		281
282	mov ebx, [eax + TCP_SOCKET.SND_NXT]	282	mov ebx, [eax + TCP_SOCKET.SND_NXT]
283	cmp ebx, [eax + TCP_SOCKET.SND_UNA]	283	cmp ebx, [eax + TCP_SOCKET.SND_UNA]
284	je .send	284	je .send
285		285
286	;--------------------	286	;--------------------
287	; Enter persist state	287	; Enter persist state
288		288
289	.enter_persist:	289	.enter_persist:
290		290
291	cmp [eax + STREAM_SOCKET.snd.size], 0 ; Data ready to send?	291	cmp [eax + STREAM_SOCKET.snd.size], 0 ; Data ready to send?
292	jne @f	292	jne @f
293	and [eax + TCP_SOCKET.timer_flags], not timer_flag_retransmission	293	and [eax + TCP_SOCKET.timer_flags], not timer_flag_retransmission
294	jne @f	294	jne @f
295		295
296	test [eax + TCP_SOCKET.timer_flags], timer_flag_persist ; Persist timer already expired?	296	test [eax + TCP_SOCKET.timer_flags], timer_flag_persist ; Persist timer already expired?
297	jnz @f	297	jnz @f
298		298
299	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_output: Entering persist state\n"	299	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_output: Entering persist state\n"
300		300
301	mov [eax + TCP_SOCKET.t_rxtshift], 0	301	mov [eax + TCP_SOCKET.t_rxtshift], 0
302	call tcp_set_persist	302	call tcp_set_persist
303	@@:	303	@@:
304		304
305	;----------------------------	305	;----------------------------
306	; No reason to send a segment	306	; No reason to send a segment
307		307
308	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_output: No reason to send a segment\n"	308	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_output: No reason to send a segment\n"
309		309
310	pusha	310	pusha
311	lea ecx, [eax + SOCKET.mutex]	311	lea ecx, [eax + SOCKET.mutex]
312	call mutex_unlock	312	call mutex_unlock
313	popa	313	popa
314		314
315	xor eax, eax	315	xor eax, eax
316	ret	316	ret
317		317
318		318
319	;-----------------------------------------------	319	;-----------------------------------------------
320	;	320	;
321	; Send a segment	321	; Send a segment
322	;	322	;
323	; eax = socket pointer	323	; eax = socket pointer
324	; esi = data len	324	; esi = data len
325	; dl = flags	325	; dl = flags
326	;	326	;
327	;-----------------------------------------------	327	;-----------------------------------------------
328	.send:	328	.send:
329		329
330	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_send: socket=%x length=%u flags=%x\n", eax, esi, dl	330	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_send: socket=%x length=%u flags=%x\n", eax, esi, dl
331		331
332	push eax ; save socket ptr	332	push eax ; save socket ptr
333	push esi ; and data length too	333	push esi ; and data length too
334	mov edi, sizeof.TCP_header ; edi will contain headersize	334	mov edi, sizeof.TCP_header ; edi will contain headersize
335		335
336	;------------------------------------	336	;------------------------------------
337	; Send options with first SYN segment	337	; Send options with first SYN segment
338		338
339	test dl, TH_SYN	339	test dl, TH_SYN
340	jz .options_done	340	jz .options_done
341		341
342	push [eax + TCP_SOCKET.ISS]	342	push [eax + TCP_SOCKET.ISS]
343	pop [eax + TCP_SOCKET.SND_NXT]	343	pop [eax + TCP_SOCKET.SND_NXT]
344		344
345	test [eax + TCP_SOCKET.t_flags], TF_NOOPT	345	test [eax + TCP_SOCKET.t_flags], TF_NOOPT
346	jnz .options_done	346	jnz .options_done
347		347
348	mov ecx, 1460 ;;;; FIXME: use routing blablabla to determine MSS	348	mov ecx, 1460 ;;;; FIXME: use routing blablabla to determine MSS
349	or ecx, TCP_OPT_MAXSEG shl 24 + 4 shl 16	349	or ecx, TCP_OPT_MAXSEG shl 24 + 4 shl 16
350	bswap ecx	350	bswap ecx
351	push ecx	351	push ecx
352	add di, 4	352	add di, 4
353		353
354	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_send: added maxseg option\n"	354	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_send: added maxseg option\n"
355		355
356	test [eax + TCP_SOCKET.t_flags], TF_REQ_SCALE	356	test [eax + TCP_SOCKET.t_flags], TF_REQ_SCALE
357	jz .no_scale	357	jz .no_scale
358		358
359	test dl, TH_ACK	359	test dl, TH_ACK
360	jz .scale_opt	360	jz .scale_opt
361		361
362	test [eax + TCP_SOCKET.t_flags], TF_RCVD_SCALE	362	test [eax + TCP_SOCKET.t_flags], TF_RCVD_SCALE
363	jz .no_scale	363	jz .no_scale
364		364
365	.scale_opt:	365	.scale_opt:
366	mov cl, [eax + TCP_SOCKET.request_r_scale]	366	mov cl, [eax + TCP_SOCKET.request_r_scale]
367	mov ch, TCP_OPT_NOP	367	mov ch, TCP_OPT_NOP
368	pushw cx	368	pushw cx
369	pushw TCP_OPT_WINDOW + 3 shl 8	369	pushw TCP_OPT_WINDOW + 3 shl 8
370	add di, 4	370	add di, 4
371		371
372	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_send: added scale option\n"	372	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_send: added scale option\n"
373		373
374	.no_scale:	374	.no_scale:
375	.no_syn:	375	.no_syn:
376		376
377	;------------------------------------	377	;------------------------------------
378	; Make the timestamp option if needed	378	; Make the timestamp option if needed
379		379
380	test [eax + TCP_SOCKET.t_flags], TF_REQ_TSTMP	380	test [eax + TCP_SOCKET.t_flags], TF_REQ_TSTMP
381	jz .no_timestamp	381	jz .no_timestamp
382		382
383	test dl, TH_RST	383	test dl, TH_RST
384	jnz .no_timestamp	384	jnz .no_timestamp
385		385
386	test dl, TH_ACK	386	test dl, TH_ACK
387	jz .timestamp	387	jz .timestamp
388		388
389	test [eax + TCP_SOCKET.t_flags], TF_RCVD_TSTMP	389	test [eax + TCP_SOCKET.t_flags], TF_RCVD_TSTMP
390	jz .no_timestamp	390	jz .no_timestamp
391		391
392	.timestamp:	392	.timestamp:
393	pushd 0	393	pushd 0
394	pushd [timer_ticks]	394	pushd [timer_ticks]
395	pushd TCP_OPT_NOP + TCP_OPT_NOP shl 8 + TCP_OPT_TIMESTAMP shl 16 + 10 shl 24	395	pushd TCP_OPT_NOP + TCP_OPT_NOP shl 8 + TCP_OPT_TIMESTAMP shl 16 + 10 shl 24
396	add di, 12	396	add di, 12
397		397
398	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_send: added timestamp\n"	398	DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_send: added timestamp\n"
399		399
400	.no_timestamp:	400	.no_timestamp:
401		401
402	;	402	;
403		403
404	.options_done:	404	.options_done:
405		405
406	; eax = socket ptr	406	; eax = socket ptr
407	; edx = flags	407	; edx = flags
408	; edi = header size	408	; edi = header size
409	; esi = data len	409	; esi = data len
410		410
411	;---------------------------------------------	411	;---------------------------------------------
412	; check if we dont exceed the max segment size	412	; check if we dont exceed the max segment size
413		413
414	add esi, edi ; total TCP segment size	414	add esi, edi ; total TCP segment size
415	cmp esi, [eax + TCP_SOCKET.t_maxseg]	415	cmp esi, [eax + TCP_SOCKET.t_maxseg]
416	jbe .no_overflow	416	jbe .no_overflow
417		417
418	mov esi, [eax + TCP_SOCKET.t_maxseg]	418	mov esi, [eax + TCP_SOCKET.t_maxseg]
419	or [temp_bits], TCP_BIT_SENDALOT	419	or [temp_bits], TCP_BIT_SENDALOT
420	.no_overflow:	420	.no_overflow:
421		421
422	; Update stats	422	; Update stats
423		423
424	test esi, esi	424	test esi, esi
425	jz .zero_data	425	jz .zero_data
426		426
427	cmp [eax + TCP_SOCKET.t_force], 1	427	test [eax + TCP_SOCKET.t_flags], TF_FORCE
428	jne @f	428	jz @f
429	cmp esi, 1	429	cmp esi, 1
430	jne @f	430	jne @f
431	inc [TCPS_sndprobe]	431	inc [TCPS_sndprobe]
432	jmp .eos	432	jmp .eos
433	@@:	433	@@:
434		434
435	mov ebx, [eax + TCP_SOCKET.SND_NXT]	435	mov ebx, [eax + TCP_SOCKET.SND_NXT]
436	cmp ebx, [eax + TCP_SOCKET.SND_MAX]	436	cmp ebx, [eax + TCP_SOCKET.SND_MAX]
437	jae @f	437	jae @f
438	inc [TCPS_sndrexmitpack]	438	inc [TCPS_sndrexmitpack]
439	add [TCPS_sndrexmitbyte], esi	439	add [TCPS_sndrexmitbyte], esi
440	jmp .eos	440	jmp .eos
441	@@:	441	@@:
442	inc [TCPS_sndpack]	442	inc [TCPS_sndpack]
443	add [TCPS_sndbyte], esi	443	add [TCPS_sndbyte], esi
444	jmp .eos	444	jmp .eos
445		445
446	.zero_data:	446	.zero_data:
447	test [eax + TCP_SOCKET.t_flags], TF_ACKNOW	447	test [eax + TCP_SOCKET.t_flags], TF_ACKNOW
448	jz @f	448	jz @f
449	inc [TCPS_sndacks]	449	inc [TCPS_sndacks]
450	jmp .eos	450	jmp .eos
451	@@:	451	@@:
452	test dl, TH_SYN + TH_FIN + TH_RST	452	test dl, TH_SYN + TH_FIN + TH_RST
453	jz @f	453	jz @f
454	inc [TCPS_sndctrl]	454	inc [TCPS_sndctrl]
455	jmp .eos	455	jmp .eos
456	@@:	456	@@:
457	mov ebx, [eax + TCP_SOCKET.SND_UP]	457	mov ebx, [eax + TCP_SOCKET.SND_UP]
458	cmp ebx, [eax + TCP_SOCKET.SND_UNA]	458	cmp ebx, [eax + TCP_SOCKET.SND_UNA]
459	jb @f	459	jb @f
460	inc [TCPS_sndurg]	460	inc [TCPS_sndurg]
461	jmp .eos	461	jmp .eos
462	@@:	462	@@:
463	inc [TCPS_sndwinup]	463	inc [TCPS_sndwinup]
464		464
465	.eos:	465	.eos:
466		466
467	;---------------------------------------------------	467	;---------------------------------------------------
468	; Dont increase sequence number when resending a FIN	468	; Dont increase sequence number when resending a FIN
469		469
470	test dl, TH_FIN	470	test dl, TH_FIN
471	jz .no_fin_retransmit	471	jz .no_fin_retransmit
472		472
473	test [eax + TCP_SOCKET.t_flags], TF_SENTFIN	473	test [eax + TCP_SOCKET.t_flags], TF_SENTFIN
474	jz .no_fin_retransmit	474	jz .no_fin_retransmit
475		475
476	mov ebx, [eax + TCP_SOCKET.SND_NXT]	476	mov ebx, [eax + TCP_SOCKET.SND_NXT]
477	cmp ebx, [eax + TCP_SOCKET.SND_MAX]	477	cmp ebx, [eax + TCP_SOCKET.SND_MAX]
478	jne .no_fin_retransmit	478	jne .no_fin_retransmit
479		479
480	dec [eax + TCP_SOCKET.SND_NXT]	480	dec [eax + TCP_SOCKET.SND_NXT]
481		481
482	.no_fin_retransmit:	482	.no_fin_retransmit:
483		483
484	;----------------------------------------------------	484	;----------------------------------------------------
485	; Calculate the receive window.	485	; Calculate the receive window.
486	; Dont shrink window, but avoid silly window syndrome	486	; Dont shrink window, but avoid silly window syndrome
487		487
488	mov ebx, SOCKET_BUFFER_SIZE	488	mov ebx, SOCKET_BUFFER_SIZE
489	sub ebx, [eax + STREAM_SOCKET.rcv.size]	489	sub ebx, [eax + STREAM_SOCKET.rcv.size]
490		490
491	cmp ebx, SOCKET_BUFFER_SIZE/4	491	cmp ebx, SOCKET_BUFFER_SIZE/4
492	jae @f	492	jae @f
493	cmp ebx, [eax + TCP_SOCKET.t_maxseg]	493	cmp ebx, [eax + TCP_SOCKET.t_maxseg]
494	jae @f	494	jae @f
495	xor ebx, ebx	495	xor ebx, ebx
496	@@:	496	@@:
497		497
498	cmp ebx, TCP_max_win	498	cmp ebx, TCP_max_win
499	jbe @f	499	jbe @f
500	mov ebx, TCP_max_win	500	mov ebx, TCP_max_win

Subversion Repositories Kolibri OS

(root)/kernel/trunk/network/tcp_output.inc – Rev 6914 → 6916