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

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/network/tcp_output.inc – Rev 5596 → 5984