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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;;  TCP.INC                                                        ;;
;;                                                                 ;;
;;  TCP Processes for Menuet OS  TCP/IP stack                      ;;
;;                                                                 ;;
;;  Version 0.6  4th July 2004                                       ;;
;;                                                                 ;;
;;  Copyright 2002 Mike Hibbett, mikeh@oceanfree.net               ;;
;;                                                                 ;;
;;  See file COPYING for details                                   ;;
;;  v0.6 : Added reset handling in the established state           ;;
;;         Added a timer per socket to allow delays when rx window ;;
;;         gets below 1KB                                          ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; TCP TCB states
TCB_LISTEN         equ        1
TCB_SYN_SENT       equ        2
TCB_SYN_RECEIVED   equ        3
TCB_ESTABLISHED    equ        4
TCB_FIN_WAIT_1     equ        5
TCB_FIN_WAIT_2     equ        6
TCB_CLOSE_WAIT     equ        7
TCB_CLOSING        equ        8
TCB_LAST_ACK       equ        9
TCB_TIME_WAIT      equ        10
TCB_CLOSED         equ        11
 
TWOMSL              equ     10      ; # of secs to wait before closing socket
 
TCP_RETRIES         equ         5               ; Number of times to resend a packet
TCP_TIMEOUT         equ         10              ; resend if not replied to in x hs
 
;*******************************************************************
;   Interface
;
;       tcp_tx_handler      Handles the TCP transmit queue
;       tcp_rx              The protocol handler for received data
;       buildTCPPacket      fills in the packet headers and data
;       tcpStateMachine     Main state machine for received TCP packets
;       tcp_tcb_handler     1s timer, to erase tcb's in TIME_WAIT state
;
;*******************************************************************
 
 
;   TCP Payload ( Data field in IP datagram )
;
;    0                   1                   2                   3
;    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
;   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
;20 |          Source Port          |       Destination Port        |
;   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
;24 |                        Sequence Number                        |
;   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
;28 |                    Acknowledgment Number                      |
;   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
;32 |  Data |           |U|A|P|R|S|F|                               |
;   | Offset| Reserved  |R|C|S|S|Y|I|            Window             |
;   |       |           |G|K|H|T|N|N|                               |
;   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
;36 |           Checksum            |         Urgent Pointer        |
;   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
;40 |                    Options                    |    Padding    |
;   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
;   |                             data
 
 
struc TCP_PACKET
{  .SourcePort       dw  ?  ;+00
   .DestinationPort  dw  ?  ;+02
   .SequenceNumber   dd  ?  ;+04
   .AckNumber        dd  ?  ;+08
   .DataOffset       db  ?  ;+12 - DataOffset[0-3 bits] and Reserved[4-7]
   .Flags            db  ?  ;+13 - Reserved[0-1 bits]|URG|ACK|PSH|RST|SYN|FIN
   .Window           dw  ?  ;+14
   .Checksum         dw  ?  ;+16
   .UrgentPointer    dw  ?  ;+18
   .Options          rb  3  ;+20
   .Padding          db  ?  ;+23
   .Data             db  ?  ;+24
}
 
virtual at 0
  TCP_PACKET TCP_PACKET
end virtual
 
 
 
;***************************************************************************
;   Function
;      tcp_tcb_handler
;
;   Description
;       Handles sockets in the timewait state, closing them
;       when the TCB timer expires
;
;***************************************************************************
tcp_tcb_handler:
    ; scan through all the sockets, decrementing active timers
 
    mov     eax, SOCKETBUFFSIZE * NUM_SOCKETS
    mov     ecx, NUM_SOCKETS
 
tth1:
    sub     eax, SOCKETBUFFSIZE
    cmp     [eax + sockets + 32], dword 0
    jne     tth2
 
tth1a:
    cmp     [eax + sockets + 72], dword 0
    jne     tth4
 
    loop    tth1
    ret
 
tth2:
    ; decrement it, delete socket if TCB timer = 0 & socket in timewait state
    pusha
    dec     dword [eax + sockets + 32]
    cmp     [eax + sockets + 32], dword 0
    jne     tth3
 
    cmp     [eax + sockets + 28], dword TCB_TIME_WAIT
    jne     tth3
 
    ; OK, delete socket
    mov     edi, eax
    add     edi, sockets
 
    xor     eax, eax
    mov     ecx, SOCKETHEADERSIZE
    cld
    rep     stosb
 
tth3:
    popa
 
    jmp     tth1a
 
    loop    tth1
    ret
 
    ; TODO - prove it works!
tth4:
    dec     dword [eax + sockets + 72]
    loop    tth1
    ret
 
 
 
 
tth_exit:
    ret
 
 
;***************************************************************************
;   Function
;      tcp_tx_handler
;
;   Description
;       Handles queued TCP data
;       This is a kernel function, called by stack_handler
;
;***************************************************************************
tcp_tx_handler:
    ; decrement all resend buffers timers. If they
    ; expire, queue them for sending, and restart the timer.
    ; If the retries counter reach 0, delete the entry
 
    mov     esi, resendQ
    mov     ecx, 0
 
tth001:
    cmp     ecx, NUMRESENDENTRIES
    je      tth003              ; None left
    cmp     [esi], byte 0xFF
    jne     tth002              ; found one
    inc     ecx
    add     esi, 4
    jmp     tth001
 
tth002:
    ; we have one. decrement it's timer by 1
    dec     word [esi+2]
    mov     ax, [esi+2]
    cmp     ax, 0
    je      tth002a
    inc     ecx
    add     esi, 4
    jmp     tth001              ; Timer not zero, so move on
 
tth002a:
    mov     bl, 0xff
    ; restart timer, and decrement retries
    ; After the first resend, back of on next, by a factor of 5
    mov     [esi+2], word TCP_TIMEOUT * 5
    dec     byte [esi+1]
    mov     al, [esi+1]
    cmp     al, 0
    jne     tth004
 
    ; retries now 0, so delete from queue
    xchg     [esi], bl
tth004:
 
    ; resend packet
    pusha
 
    mov     eax, EMPTY_QUEUE
    call    dequeue
    cmp     ax, NO_BUFFER
    jne      tth004z
 
    ; TODO - try again in 10ms.
    cmp     bl, 0xff
    jne     tth004za
    mov     [esi], bl
 
tth004za:
    ; Mark it to expire in 10ms - 1 tick
    mov     [esi+1], byte 1
    mov     [esi+2], word 1
    jmp     tth005
 
tth004z:
    ; we have a buffer # in ax
 
    push    eax
    push    ecx
    mov     ecx, IPBUFFSIZE
    mul     ecx
    add     eax, IPbuffs
 
    ; we have the buffer address in eax
    mov     edi, eax
    pop     ecx
    ; get resend data address
    inc     ecx
    ; Now get buffer location, and copy buffer across. argh! more copying,,
    mov     esi, resendBuffer - IPBUFFSIZE
tth004a:
    add     esi, IPBUFFSIZE
    loop    tth004a
 
    ; we have resend buffer location in esi
    mov     ecx, IPBUFFSIZE
 
    ; copy data across
    cld
    rep     movsb
 
    ; queue packet
 
 
 
    mov     eax, NET1OUT_QUEUE
 
    mov     edx, [stack_ip]
    mov     ecx, [ edi + 16 ]
    cmp     edx, ecx
    jne     tth004b
    mov     eax, IPIN_QUEUE
 
tth004b:
    pop     ebx
 
    call    queue
 
 
tth005:
    popa
 
    inc     ecx
    add     esi, 4
    jmp     tth001
 
tth003:
    ret
 
 
 
 
;***************************************************************************
;   Function
;      tcp_rx
;
;   Description
;       TCP protocol handler
;       This is a kernel function, called by ip_rx
;       IP buffer address given in edx
;          IP buffer number in eax
;          Free up (or re-use) IP buffer when finished
;
;***************************************************************************
tcp_rx:
    ; The process is as follows.
    ; Look for a socket with matching remote IP, remote port, local port
    ; if not found, then
    ; look for remote IP + local port match ( where sockets remote port = 0)
    ; if not found, then
    ; look for a socket where local socket port == IP packets remote port
    ; where sockets remote port, remote IP = 0
    ; discard if not found
    ; Call sockets tcbStateMachine, with pointer to packet.
    ; the state machine will not delete the packet, so do that here.
 
    push        eax
 
    ; Look for a socket where
    ; IP Packet TCP Destination Port = local Port
    ; IP Packet SA = Remote IP
    ; IP Packet TCP Source Port = remote Port
 
    mov     eax, SOCKETBUFFSIZE * NUM_SOCKETS
    mov     ecx, NUM_SOCKETS
ss1:
    sub     eax, SOCKETBUFFSIZE
    movzx   ebx, word [edx + 22]     ; get the dest. port from the TCP hdr
    cmp     [eax + sockets + 12], bx ; compare with socket's local port
    jnz     nxttst1                        ; different - try next socket
 
    movzx   ebx, word [edx + 20]       ; get the source port from the TCP hdr
    cmp     [eax + sockets + 20], bx ; compare with socket's remote port
    jnz     nxttst1                        ; different - try next socket
 
 
    mov     ebx, [edx + 12]           ; get the source IP Addr from the IP hdr
    cmp     [eax + sockets + 16], ebx ; compare with socket's remote IP
    jnz     nxttst1                        ; different - try next socket
 
    ; We have a complete match - use this socket
    jmp     tcprx_001
 
nxttst1:
    loop    ss1                     ; Return back if no match
 
    ; If we got here, there was no match
    ; Look for a socket where
    ; IP Packet TCP Destination Port = local Port
    ; IP Packet SA = Remote IP
    ; socket remote Port = 0
 
    mov     eax, SOCKETBUFFSIZE * NUM_SOCKETS
    mov     ecx, NUM_SOCKETS
 
ss2:
    sub     eax, SOCKETBUFFSIZE
 
    movzx   ebx, word [edx + 22]     ; get the dest. port from the TCP hdr
    cmp     [eax + sockets + 12], bx ; compare with socket's local port
    jnz     nxttst2                        ; different - try next socket
 
    mov     ebx, [edx + 12]          ; get the source IP Addr from the IP hdr
    cmp     [eax + sockets + 16], ebx ; compare with socket's remote IP
    jnz     nxttst2                        ; different - try next socket
 
    mov     ebx, 0
    cmp     [eax + sockets + 20], bx ; only match a remote socket of 0
    jnz     nxttst2                        ; different - try next socket
 
    ; We have a complete match - use this socket
    jmp     tcprx_001
 
nxttst2:
    loop    ss2                     ; Return back if no match
 
    ; If we got here, there was no match
    ; Look for a socket where
    ; IP Packet TCP Destination Port = local Port
    ; socket Remote IP = 0
    ; socket remote Port = 0
 
    mov     eax, SOCKETBUFFSIZE * NUM_SOCKETS
    mov     ecx, NUM_SOCKETS
 
ss3:
    sub     eax, SOCKETBUFFSIZE
 
    movzx   ebx, word [edx + 22]     ; get destination port from the TCP hdr
    cmp     [eax + sockets + 12], bx ; compare with socket's local port
    jnz     nxttst3                        ; different - try next socket
 
    mov     ebx, 0
    cmp     [eax + sockets + 20], bx ; only match a remote socket of 0
    jnz     nxttst3                        ; different - try next socket
 
    mov     ebx, 0
    cmp     [eax + sockets + 16], ebx ; only match a socket remote IP of 0
    jnz     nxttst3                        ; different - try next socket
 
    ; We have a complete match - use this socket
    jmp     tcprx_001
 
nxttst3:
    loop    ss3                     ; Return back if no match
 
    ; If we got here, we need to reject the packet
    inc     dword [dumped_rx_count]
    jmp     tcprx_exit
 
tcprx_001:
    ; We have a valid socket/TCB, so call the TCB State Machine for that skt.
    ; socket is pointed to by [eax + sockets]
    ; IP packet is pointed to by [edx]
    ; IP buffer number is on stack ( it will be popped at the end)
    call    tcpStateMachine
 
tcprx_exit:
    pop     eax
    call    freeBuff
 
    ret
 
 
 
;***************************************************************************
;   Function
;      buildTCPPacket
;
;   Description
;       builds an IP Packet with TCP data fully populated for transmission
;       You may destroy any and all registers
;          TCP control flags specified in bl
;          This TCB is in [sktAddr]
;          User data pointed to by esi
;       Data length in ecx
;          Transmit buffer number in eax
;
;***************************************************************************
buildTCPPacket:
    push    ecx                        ; Save data length
 
    ; convert buffer pointer eax to the absolute address
    mov     ecx, IPBUFFSIZE
    mul     ecx
    add     eax, IPbuffs
 
    mov     edx, eax
 
    mov     [edx + 33], bl            ; TCP flags
 
    mov     ebx, [sktAddr]
 
    ; So, ebx holds the socket ptr, edx holds the IPbuffer ptr
 
    ; Fill in the IP header ( some data is in the socket descriptor)
    mov     eax, [ebx + 8]
    mov     [edx + 12], eax      ; source IP
    mov     eax, [ebx + 16]
    mov     [edx + 16], eax      ; Destination IP
 
    mov     al, 0x45
    mov     [edx], al         ; Version, IHL
    xor     al, al
    mov     [edx + 1], al     ; Type of service
 
    pop     eax                   ; Get the TCP data length
    push    eax
 
    add     eax, 20 + 20           ; add IP header and TCP header lengths
    mov     [edx + 2], ah
    mov     [edx + 3], al
    xor     al, al
    mov     [edx + 4], al
    mov     [edx + 5], al
    mov     al, 0x40
    mov     [edx + 6], al
    xor     al, al
    mov     [edx + 7], al
    mov     al, 0x20
    mov     [edx + 8], al
    mov     al, 6                         ; TCP protocol
    mov     [edx + 9], al
 
    ; Checksum left unfilled
    xor     ax, ax
    mov     [edx + 10], ax
 
    ; Fill in the TCP header ( some data is in the socket descriptor)
    mov     ax, [ebx + 12]
    mov     [edx + 20], ax        ; Local Port
 
    mov     ax, [ebx + 20]
    mov     [edx + 20 + 2], ax    ; desitination Port
 
    ; Checksum left unfilled
    xor     ax, ax
    mov     [edx + 20 + 16], ax
 
    ; sequence number
    mov     eax, [ebx + 48]
    mov     [edx + 20 + 4], eax
 
    ; ack number
    mov     eax, [ebx + 56]
    mov     [edx + 20 + 8], eax
 
    ; window ( 0x2000 is default ).I could accept 4KB, fa0, ( skt buffer size)
    ; 768 bytes seems better
    mov     ax, 0x0003
    mov     [edx + 20 + 14], ax
 
    ; Urgent pointer (0)
    mov     ax, 0
    mov     [edx + 20 + 18], ax
 
    ; data offset ( 0x50 )
    mov     al, 0x50
    mov     [edx + 20 + 12], al
 
    pop     ecx                  ; count of bytes to send
    mov     ebx, ecx            ; need the length later
 
    cmp     ebx, 0
    jz      btp_001
 
    mov     edi, edx
    add     edi, 40
    cld
    rep     movsb               ; copy the data across
 
btp_001:
    ; we have edx as IPbuffer ptr.
    ; Fill in the TCP checksum
    ; First, fill in pseudoheader
    mov     eax, [edx + 12]
    mov     [pseudoHeader], eax
    mov     eax, [edx + 16]
    mov     [pseudoHeader+4], eax
    mov     ax, 0x0600            ; 0 + protocol
    mov     [pseudoHeader+8], ax
    add     ebx, 20
    mov     eax, ebx
    mov     [pseudoHeader+10], ah
    mov     [pseudoHeader+11], al
 
    mov     eax, pseudoHeader
    mov     [checkAdd1], eax
    mov     [checkSize1], word 12
    mov     eax, edx
    add     eax, 20
    mov     [checkAdd2], eax
    mov     eax, ebx
    mov     [checkSize2], ax
 
    call    checksum
 
    ; store it in the TCP checksum ( in the correct order! )
    mov     ax, [checkResult]
 
    mov     [edx + 20 + 16], ah
    mov     [edx + 20 + 17], al
 
    ; Fill in the IP header checksum
    GET_IHL eax,edx              ; get IP-Header length
    stdcall checksum_jb,edx,eax  ; buf_ptr, buf_size
 
    mov     [edx + 10], ah
    mov     [edx + 11], al
 
    ret
 
 
; Increments the 32 bit value pointed to by esi in internet order
inc_inet_esi:
    push    eax
    add     esi, 3
    mov     al, byte[esi]
    inc     al
    mov     byte[esi], al
    cmp     al, 0
    jnz     iie_exit
    dec     esi
    mov     al, byte[esi]
    inc     al
    mov     byte[esi], al
    cmp     al, 0
    jnz     iie_exit
    dec     esi
    mov     al, byte[esi]
    inc     al
    mov     byte[esi], al
    cmp     al, 0
    jnz     iie_exit
    dec     esi
    mov     al, byte[esi]
    inc     al
    mov     byte[esi], al
 
iie_exit:
    pop     eax
    ret
 
 
; Increments the 32 bit value pointed to by esi in internet order
; by the value in ecx
add_inet_esi:
    push    eax
 
    mov     al, [esi]
    shl     eax, 8
    inc     esi
    mov     al, [esi]
    shl     eax, 8
    inc     esi
    mov     al, [esi]
    shl     eax, 8
    inc     esi
    mov     al, [esi]
    add     eax, ecx
    mov     [esi], al
    dec     esi
    shr     eax, 8
    mov     [esi], al
    dec     esi
    shr     eax, 8
    mov     [esi], al
    dec     esi
    shr     eax, 8
    mov     [esi], al
    pop     eax
    ret
 
 
iglobal
  TCBStateHandler:
    dd      stateTCB_LISTEN
    dd      stateTCB_SYN_SENT
    dd      stateTCB_SYN_RECEIVED
    dd      stateTCB_ESTABLISHED
    dd      stateTCB_FIN_WAIT_1
    dd      stateTCB_FIN_WAIT_2
    dd      stateTCB_CLOSE_WAIT
    dd      stateTCB_CLOSING
    dd      stateTCB_LAST_ACK
    dd      stateTCB_TIME_WAIT
    dd      stateTCB_CLOSED
endg
 
;***************************************************************************
;   Function
;      tcpStateMachine
;
;   Description
;       TCP state machine
;       This is a kernel function, called by tcp_rx
;
;       IP buffer address given in edx
;          Socket/TCB address in [eax + sockets]
;
;       The IP buffer will be released by the caller
;***************************************************************************
tcpStateMachine:
    mov     ebx, sockets
    add     ebx, eax
    mov     [sktAddr], ebx
 
    ; as a packet has been received, update the TCB timer
    mov     ecx, TWOMSL
    mov     [ebx + 32], ecx
 
    ; If the received packet has an ACK bit set,
    ; remove any packets in the resend queue that this
    ; received packet acknowledges
    pusha
    mov     cl, [edx + 33]
    and     cl, 0x10
    cmp     cl, 0x10
    jne     tsm001                      ; No ACK, so no data yet
 
 
    ; get skt number in al
    shr     eax, 12
 
    ; The ack number is in [edx + 28], inet format
    ; skt in al
 
    mov     esi, resendQ
    mov     ecx, 0
 
t001:
    cmp     ecx, NUMRESENDENTRIES
    je      t003              ; None left
    cmp     [esi], al
    je      t002              ; found one
    inc     ecx
    add     esi, 4
    jmp     t001
 
t002:                   ; Can we delete this buffer?
 
                        ; If yes, goto t004. No, goto t001
    ; Get packet data address
 
    push    ecx
    inc     ecx
    ; Now get buffer location, and copy buffer across. argh! more copying,,
    mov     edi, resendBuffer - IPBUFFSIZE
t002a:
    add     edi, IPBUFFSIZE
    loop    t002a
 
    ; we have dest buffer location in edi. incoming packet in edx.
    ; Get this packets sequence number
    ; preserve al, ecx, esi, edx
 
    mov     cl, [edi + 24]
    shl     ecx, 8
    mov     cl, [edi + 25]
    shl     ecx, 8
    mov     cl, [edi + 26]
    shl     ecx, 8
    mov     cl, [edi + 27]
    movzx   ebx, byte [edi + 3]
    mov     bh, [edi + 2]
    sub     ebx, 40
    add     ecx, ebx          ; ecx is now seq# of last byte +1, intel format
 
    ; get recievd ack #, in intel format
    mov     bl, [edx + 28]
    shl     ebx, 8
    mov     bl, [edx + 29]
    shl     ebx, 8
    mov     bl, [edx + 30]
    shl     ebx, 8
    mov     bl, [edx + 31]
 
    cmp     ebx, ecx        ; Finally. ecx = rx'ed ack. ebx = last byte in que
                            ; DANGER! need to handle case that we have just
                            ; passed the 2**32, and wrapped round!
    pop     ecx
 
    jae     t004             ; if rx > old, delete old
    inc     ecx
    add     esi, 4
    jmp     t001
 
 
t004:
    dec     dword [arp_rx_count] ; ************ TEST ONLY!
 
    mov     [esi], byte 0xFF
    inc     ecx
    add     esi, 4
    jmp     t001
 
t003:
 
tsm001:
    popa
 
    ; Call handler for given TCB state
    mov     ebx, [eax + sockets+28]
    cmp     ebx, TCB_LISTEN
    jb      tsm_exit
    cmp     ebx, TCB_CLOSED
    ja      tsm_exit
 
    dec     ebx
    call    dword [TCBStateHandler+ebx*4]
 
tsm_exit:
    ret
 
 
 
stateTCB_LISTEN:
    ; In this case, we are expecting a SYN packet
    ; For now, if the packet is a SYN, process it, and send a response
    ; If not, ignore it
 
    ; Look at control flags
    mov     bl, [edx + 33]
    and     bl, 0x02
    cmp     bl, 0x02
    jnz     stl_exit
 
    ; We have a SYN. update the socket with this IP packets details,
    ; And send a response
 
    mov     ebx, [edx + 12] ; IP source address
    mov     [eax + sockets + 16], ebx
    mov     bx, [edx + 20] ; IP source port
    mov     [eax + sockets + 20], bx
    mov     ebx, [edx + 24] ; IRS
    mov     [eax + sockets + 40], ebx
    mov     [eax + sockets + 56], ebx
    mov     esi, sockets
    add     esi, eax
    add     esi, 56
    call    inc_inet_esi ; RCV.NXT
    mov     ebx, [eax + sockets + 36]    ; ISS
    mov     [eax + sockets + 48], ebx    ; SND.NXT
 
    ; Now construct the response, and queue for sending by IP
    mov     eax, EMPTY_QUEUE
    call    dequeue
    cmp     ax, NO_BUFFER
    je      stl_exit
 
    push    eax
    mov     bl, 0x12        ; SYN + ACK
    mov     ecx, 0
    mov     esi, 0
 
    call    buildTCPPacket
 
    mov     eax, NET1OUT_QUEUE
    mov     edx, [stack_ip]
    mov     ecx, [ sktAddr ]
    mov     ecx, [ ecx + 16 ]
    cmp     edx, ecx
    jne     stl_notlocal
    mov     eax, IPIN_QUEUE
 
stl_notlocal:
       ; Send it.
    pop     ebx
    call    queue
 
 
    mov     ebx, TCB_SYN_RECEIVED
    mov     esi, [sktAddr]
    mov     [esi + 28], ebx
 
    ; increament SND.NXT in socket
    add     esi, 48
    call    inc_inet_esi
 
stl_exit:
    ret
 
 
 
stateTCB_SYN_SENT:
    ; We are awaiting an ACK to our SYN, with a SYM
    ; Look at control flags - expecting an ACK
    mov     bl, [edx + 33]
    and     bl, 0x12
    cmp     bl, 0x12
    jnz     stss_exit
 
    mov     ebx, TCB_ESTABLISHED
    mov     esi, [sktAddr]
    mov     [esi + 28], ebx
 
    ; Store the recv.nxt field
    mov     eax, [edx + 24]
 
    ; Update our recv.nxt field
    mov     esi, [sktAddr]
    add     esi, 56
    mov     [esi], eax
    call    inc_inet_esi
 
    ; Send an ACK
    ; Now construct the response, and queue for sending by IP
    mov     eax, EMPTY_QUEUE
    call    dequeue
    cmp     ax, NO_BUFFER
    je      stss_exit
 
    push    eax
 
    mov     bl, 0x10        ; ACK
    mov     ecx, 0
    mov     esi, 0
 
    call    buildTCPPacket
 
    mov     eax, NET1OUT_QUEUE
 
    mov     edx, [stack_ip]
    mov     ecx, [ sktAddr ]
    mov     ecx, [ ecx + 16 ]
    cmp     edx, ecx
    jne     stss_notlocal
    mov     eax, IPIN_QUEUE
 
stss_notlocal:
       ; Send it.
    pop     ebx
    call    queue
 
stss_exit:
    ret
 
 
 
stateTCB_SYN_RECEIVED:
    ; In this case, we are expecting an ACK packet
    ; For now, if the packet is an ACK, process it,
    ; If not, ignore it
 
    ; Look at control flags - expecting an ACK
    mov     bl, [edx + 33]
    and     bl, 0x10
    cmp     bl, 0x10
    jnz     stsr_exit
 
    mov     ebx, TCB_ESTABLISHED
    mov     esi, [sktAddr]
    mov     [esi + 28], ebx
 
stsr_exit:
    ret
 
 
 
stateTCB_ESTABLISHED:
    ; Here we are expecting data, or a request to close
    ; OR both...
 
    ; Did we receive a FIN or RST?
    mov     bl, [edx + 33]
    and     bl, 0x05
    cmp     bl, 0
    je      ste_chkack
 
    ; It was a fin or reset.
 
    ; Remove resend entries from the queue  - I dont want to send any more data
    pusha
 
    mov     ebx, [sktAddr]
    sub     ebx, sockets
    shr     ebx, 12             ; get skt #
 
    mov     esi, resendQ
    mov     ecx, 0
 
ste001:
    cmp     ecx, NUMRESENDENTRIES
    je      ste003              ; None left
    cmp     [esi], bl
    je      ste002              ; found one
    inc     ecx
    add     esi, 4
    jmp     ste001
 
ste002:
    dec     dword [arp_rx_count] ; ************ TEST ONLY!
 
    mov     [esi], byte 0xFF
    jmp     ste001
 
ste003:
    popa
 
    ; was it a reset?
    mov     bl, [edx + 33]
    and     bl, 0x04
    cmp     bl, 0x04
    jne     ste003a
 
    mov     esi, [sktAddr]
    mov     ebx, TCB_CLOSED
    mov     [esi + 28], ebx
    jmp     ste_exit
 
ste003a:
    ; Send an ACK to that fin, and enter closewait state
 
    mov     esi, [sktAddr]
    mov     ebx, TCB_CLOSE_WAIT
    mov     [esi + 28], ebx
    add     esi, 56
    mov     eax, [esi]              ; save original
    call    inc_inet_esi
    ;; jmp    ste_ack - NO, there may be data
 
ste_chkack:
    ; Check that we received an ACK
    mov     bl, [edx + 33]
    and     bl, 0x10
    cmp     bl, 0x10
    jnz     ste_exit
 
 
    ; TODO - done, I think!
    ; First, look at the incoming window. If this is less than or equal to 1024,
    ; Set the socket window timer to 1. This will stop an additional packets being
    ; queued.
    ; ** I may need to tweak this value, since I do not know how many packets are already queued
    mov     ch, [edx + 34]
    mov     cl, [edx + 35]
    cmp     cx, 1024
    ja      ste004
 
    mov     ecx, [sktAddr]
    mov     [ecx+72], dword 1
 
ste004:
 
    ; OK, here is the deal
    ; My recv.nct field holds the seq of the expected next rec byte
    ; if the recevied sequence number is not equal to this, do not
    ; increment the recv.nxt field, do not copy data - just send a
    ; repeat ack.
 
    ; recv.nxt is in dword [edx+24], in inext format
    ; recv seq is in [sktAddr]+56, in inet format
    ; just do a comparision
    mov     ecx, [sktAddr]
    add     ecx, 56
 
    cmp     [ecx - 56 + 28], dword TCB_CLOSE_WAIT
    mov     ecx, [ecx]
    jne     stenofin
    mov     ecx, eax
 
stenofin:
    cmp     ecx, [edx+24]
    jne     ste_ack
 
 
    ; Read the data bytes, store in socket buffer
    xor     ecx, ecx
    mov     ch, [edx + 2]
    mov     cl, [edx + 3]
    sub     ecx, 40                    ; Discard 40 bytes of header
 
    cmp     ecx, 0
    jnz     ste_data                ; Read data, if any
 
    ; If we had received a fin, we need to ACK it.
    mov     esi, [sktAddr]
    mov     ebx, [esi + 28]
    cmp     ebx, TCB_CLOSE_WAIT
    jz      ste_ack
    jnz     ste_exit
 
ste_data:
    push    ecx
    mov     esi, [sktAddr]
 
    add     [esi + 24], ecx      ; increment the count of bytes in buffer
 
    mov     eax, [esi + 4]       ; get socket owner PID
    push    eax
 
    mov     eax, [esi + 24]      ; get # of bytes already in buffer
 
    ; point to the location to store the data
    add     esi, eax
    sub     esi, ecx
    add     esi, SOCKETHEADERSIZE
 
    add     edx, 40        ; edx now points to the data
    mov     edi, esi
    mov     esi, edx
 
    cld
    rep     movsb          ; copy the data across
 
    ; flag an event to the application
    pop     eax
    mov     ecx,1
    mov     esi,TASK_DATA+TASKDATA.pid
 
news:
    cmp     [esi],eax
    je      foundPID1
    inc     ecx
    add     esi,0x20
    cmp     ecx,[TASK_COUNT]
    jbe     news
 
foundPID1:
    shl     ecx,8
    or      dword [ecx+0x80000+APPDATA.event_mask],dword 10000000b ; stack event
 
    pop     ecx
 
    ; Update our recv.nxt field
    mov     esi, [sktAddr]
    add     esi, 56
    call    add_inet_esi
 
ste_ack:
    ; Send an ACK
    ; Now construct the response, and queue for sending by IP
    mov     eax, EMPTY_QUEUE
    call    dequeue
    cmp     ax, NO_BUFFER
    je      ste_exit
 
    push    eax
 
    mov     bl, 0x10        ; ACK
    mov     ecx, 0
    mov     esi, 0
 
    call    buildTCPPacket
 
    mov     eax, NET1OUT_QUEUE
 
    mov     edx, [stack_ip]
    mov     ecx, [ sktAddr ]
    mov     ecx, [ ecx + 16 ]
    cmp     edx, ecx
    jne     ste_notlocal
    mov     eax, IPIN_QUEUE
ste_notlocal:
 
       ; Send it.
    pop     ebx
    call    queue
 
ste_exit:
    ret
 
 
 
stateTCB_FIN_WAIT_1:
    ; We can either receive an ACK of a fin, or a fin
    mov     bl, [edx + 33]
    and     bl, 0x10
    cmp     bl, 0x10
    jnz     stfw1_001
 
    ; It was an ACK
    mov     esi, [sktAddr]
    mov     ebx, TCB_FIN_WAIT_2
    mov     [esi + 28], ebx
    jmp     stfw1_exit
 
stfw1_001:
    ; It must be a fin then
    mov     esi, [sktAddr]
    mov     ebx, TCB_CLOSING
    mov     [esi + 28], ebx
    add     esi, 56
    call    inc_inet_esi
 
    ; Send an ACK
    mov     eax, EMPTY_QUEUE
    call    dequeue
    cmp     ax, NO_BUFFER
    je      stfw1_exit
 
    push    eax
 
    mov     bl, 0x10        ; ACK
    mov     ecx, 0
    mov     esi, 0
 
    call    buildTCPPacket
    mov     eax, NET1OUT_QUEUE
 
    mov     edx, [stack_ip]
    mov     ecx, [ sktAddr ]
    mov     ecx, [ ecx + 16 ]
    cmp     edx, ecx
    jne     stfw1_notlocal
    mov     eax, IPIN_QUEUE
 
stfw1_notlocal:
    ; Send it.
    pop     ebx
    call    queue
 
stfw1_exit:
    ret
 
 
 
stateTCB_FIN_WAIT_2:
    mov     esi, [sktAddr]
 
    ; Get data length
    xor     ecx, ecx
    mov     ch, [edx+2]
    mov     cl, [edx+3]
    sub     ecx, 40
 
    mov     bl, [edx + 33]
    and     bl, 0x01
    cmp     bl, 0x01
    jne     stfw2001
 
    ; Change state, as we have a fin
    mov     ebx, TCB_TIME_WAIT
    mov     [esi + 28], ebx
 
    inc     ecx                     ; FIN is part of the sequence space
 
stfw2001:
    add     esi, 56
    call    add_inet_esi
 
    ; Send an ACK
    mov     eax, EMPTY_QUEUE
    call    dequeue
    cmp     ax, NO_BUFFER
    je      stfw2_exit
 
    push    eax
 
    mov     bl, 0x10        ; ACK
    mov     ecx, 0
    mov     esi, 0
 
    call    buildTCPPacket
 
    mov     eax, NET1OUT_QUEUE
 
    mov     edx, [stack_ip]
    mov     ecx, [ sktAddr ]
    mov     ecx, [ ecx + 16 ]
    cmp     edx, ecx
    jne     stfw2_notlocal
    mov     eax, IPIN_QUEUE
 
stfw2_notlocal:
       ; Send it.
    pop     ebx
    call    queue
 
    ; Only delete the socket if we received the FIN
 
    mov     bl, [edx + 33]
    and     bl, 0x01
    cmp     bl, 0x01
    jne     stfw2_exit
 
;    mov     edi, [sktAddr]
 
    ; delete the socket. Should really wait for 2MSL
;    xor     eax, eax
;    mov     ecx,SOCKETHEADERSIZE
;    cld
;    rep     stosb
 
stfw2_exit:
    ret
 
 
 
stateTCB_CLOSE_WAIT:
    ; Intentionally left empty
    ; socket_close_tcp handles this
    ret
 
 
 
stateTCB_CLOSING:
    ; We can either receive an ACK of a fin, or a fin
    mov     bl, [edx + 33]
    and     bl, 0x10
    cmp     bl, 0x10
    jnz     stc_exit
 
    ; It was an ACK
 
    mov     edi, [sktAddr]
 
    ; delete the socket
    xor     eax, eax
    mov     ecx,SOCKETHEADERSIZE
    cld
    rep     stosb
 
stc_exit:
    ret
 
 
 
stateTCB_LAST_ACK:
    ; Look at control flags - expecting an ACK
    mov     bl, [edx + 33]
    and     bl, 0x10
    cmp     bl, 0x10
    jnz     stla_exit
 
    mov     edi, [sktAddr]
 
    ; delete the socket
    xor     eax, eax
    mov     ecx,SOCKETHEADERSIZE
    cld
    rep     stosb
 
stla_exit:
    ret
 
 
 
stateTCB_TIME_WAIT:
    ret
 
 
 
stateTCB_CLOSED:
    ret

Rev 261	Rev 379
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; TCP.INC ;;	3	;; TCP.INC ;;
4	;; ;;	4	;; ;;
5	;; TCP Processes for Menuet OS TCP/IP stack ;;	5	;; TCP Processes for Menuet OS TCP/IP stack ;;
6	;; ;;	6	;; ;;
7	;; Version 0.6 4th July 2004 ;;	7	;; Version 0.6 4th July 2004 ;;
8	;; ;;	8	;; ;;
9	;; Copyright 2002 Mike Hibbett, mikeh@oceanfree.net ;;	9	;; Copyright 2002 Mike Hibbett, mikeh@oceanfree.net ;;
10	;; ;;	10	;; ;;
11	;; See file COPYING for details ;;	11	;; See file COPYING for details ;;
12	;; v0.6 : Added reset handling in the established state ;;	12	;; v0.6 : Added reset handling in the established state ;;
13	;; Added a timer per socket to allow delays when rx window ;;	13	;; Added a timer per socket to allow delays when rx window ;;
14	;; gets below 1KB ;;	14	;; gets below 1KB ;;
15	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	15	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
16		16
17	; TCP TCB states	17	; TCP TCB states
18	TCB_LISTEN equ 1	18	TCB_LISTEN equ 1
19	TCB_SYN_SENT equ 2	19	TCB_SYN_SENT equ 2
20	TCB_SYN_RECEIVED equ 3	20	TCB_SYN_RECEIVED equ 3
21	TCB_ESTABLISHED equ 4	21	TCB_ESTABLISHED equ 4
22	TCB_FIN_WAIT_1 equ 5	22	TCB_FIN_WAIT_1 equ 5
23	TCB_FIN_WAIT_2 equ 6	23	TCB_FIN_WAIT_2 equ 6
24	TCB_CLOSE_WAIT equ 7	24	TCB_CLOSE_WAIT equ 7
25	TCB_CLOSING equ 8	25	TCB_CLOSING equ 8
26	TCB_LAST_ACK equ 9	26	TCB_LAST_ACK equ 9
27	TCB_TIME_WAIT equ 10	27	TCB_TIME_WAIT equ 10
28	TCB_CLOSED equ 11	28	TCB_CLOSED equ 11
29		29
30	TWOMSL equ 10 ; # of secs to wait before closing socket	30	TWOMSL equ 10 ; # of secs to wait before closing socket
31		31
32	TCP_RETRIES equ 5 ; Number of times to resend a packet	32	TCP_RETRIES equ 5 ; Number of times to resend a packet
33	TCP_TIMEOUT equ 10 ; resend if not replied to in x hs	33	TCP_TIMEOUT equ 10 ; resend if not replied to in x hs
34		34
35	;*******************************************************************	35	;*******************************************************************
36	; Interface	36	; Interface
37	;	37	;
38	; tcp_tx_handler Handles the TCP transmit queue	38	; tcp_tx_handler Handles the TCP transmit queue
39	; tcp_rx The protocol handler for received data	39	; tcp_rx The protocol handler for received data
40	; buildTCPPacket fills in the packet headers and data	40	; buildTCPPacket fills in the packet headers and data
41	; tcpStateMachine Main state machine for received TCP packets	41	; tcpStateMachine Main state machine for received TCP packets
42	; tcp_tcb_handler 1s timer, to erase tcb's in TIME_WAIT state	42	; tcp_tcb_handler 1s timer, to erase tcb's in TIME_WAIT state
43	;	43	;
44	;*******************************************************************	44	;*******************************************************************
45		45
46		46
47	; TCP Payload ( Data field in IP datagram )	47	; TCP Payload ( Data field in IP datagram )
48	;	48	;
49	; 0 1 2 3	49	; 0 1 2 3
50	; 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1	50	; 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
51	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	51	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
52	;20 \| Source Port \| Destination Port \|	52	;20 \| Source Port \| Destination Port \|
53	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	53	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
54	;24 \| Sequence Number \|	54	;24 \| Sequence Number \|
55	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	55	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
56	;28 \| Acknowledgment Number \|	56	;28 \| Acknowledgment Number \|
57	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	57	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
58	;32 \| Data \| \|U\|A\|P\|R\|S\|F\| \|	58	;32 \| Data \| \|U\|A\|P\|R\|S\|F\| \|
59	; \| Offset\| Reserved \|R\|C\|S\|S\|Y\|I\| Window \|	59	; \| Offset\| Reserved \|R\|C\|S\|S\|Y\|I\| Window \|
60	; \| \| \|G\|K\|H\|T\|N\|N\| \|	60	; \| \| \|G\|K\|H\|T\|N\|N\| \|
61	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	61	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
62	;36 \| Checksum \| Urgent Pointer \|	62	;36 \| Checksum \| Urgent Pointer \|
63	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	63	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
64	;40 \| Options \| Padding \|	64	;40 \| Options \| Padding \|
65	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	65	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
66	; \| data	66	; \| data
67		67
68		68
69	struc TCP_PACKET	69	struc TCP_PACKET
70	{ .SourcePort dw ? ;+00	70	{ .SourcePort dw ? ;+00
71	.DestinationPort dw ? ;+02	71	.DestinationPort dw ? ;+02
72	.SequenceNumber dd ? ;+04	72	.SequenceNumber dd ? ;+04
73	.AckNumber dd ? ;+08	73	.AckNumber dd ? ;+08
74	.DataOffset db ? ;+12 - DataOffset[0-3 bits] and Reserved[4-7]	74	.DataOffset db ? ;+12 - DataOffset[0-3 bits] and Reserved[4-7]
75	.Flags db ? ;+13 - Reserved[0-1 bits]\|URG\|ACK\|PSH\|RST\|SYN\|FIN	75	.Flags db ? ;+13 - Reserved[0-1 bits]\|URG\|ACK\|PSH\|RST\|SYN\|FIN
76	.Window dw ? ;+14	76	.Window dw ? ;+14
77	.Checksum dw ? ;+16	77	.Checksum dw ? ;+16
78	.UrgentPointer dw ? ;+18	78	.UrgentPointer dw ? ;+18
79	.Options rb 3 ;+20	79	.Options rb 3 ;+20
80	.Padding db ? ;+23	80	.Padding db ? ;+23
81	.Data db ? ;+24	81	.Data db ? ;+24
82	}	82	}
83		83
84	virtual at 0	84	virtual at 0
85	TCP_PACKET TCP_PACKET	85	TCP_PACKET TCP_PACKET
86	end virtual	86	end virtual
87		87
88		88
89		89
90	;***************************************************************************	90	;***************************************************************************
91	; Function	91	; Function
92	; tcp_tcb_handler	92	; tcp_tcb_handler
93	;	93	;
94	; Description	94	; Description
95	; Handles sockets in the timewait state, closing them	95	; Handles sockets in the timewait state, closing them
96	; when the TCB timer expires	96	; when the TCB timer expires
97	;	97	;
98	;***************************************************************************	98	;***************************************************************************
99	tcp_tcb_handler:	99	tcp_tcb_handler:
100	; scan through all the sockets, decrementing active timers	100	; scan through all the sockets, decrementing active timers
101		101
102	mov eax, SOCKETBUFFSIZE * NUM_SOCKETS	102	mov eax, SOCKETBUFFSIZE * NUM_SOCKETS
103	mov ecx, NUM_SOCKETS	103	mov ecx, NUM_SOCKETS
104		104
105	tth1:	105	tth1:
106	sub eax, SOCKETBUFFSIZE	106	sub eax, SOCKETBUFFSIZE
107	cmp [eax + sockets + 32], dword 0	107	cmp [eax + sockets + 32], dword 0
108	jne tth2	108	jne tth2
109		109
110	tth1a:	110	tth1a:
111	cmp [eax + sockets + 72], dword 0	111	cmp [eax + sockets + 72], dword 0
112	jne tth4	112	jne tth4
113		113
114	loop tth1	114	loop tth1
115	ret	115	ret
116		116
117	tth2:	117	tth2:
118	; decrement it, delete socket if TCB timer = 0 & socket in timewait state	118	; decrement it, delete socket if TCB timer = 0 & socket in timewait state
119	pusha	119	pusha
120	dec dword [eax + sockets + 32]	120	dec dword [eax + sockets + 32]
121	cmp [eax + sockets + 32], dword 0	121	cmp [eax + sockets + 32], dword 0
122	jne tth3	122	jne tth3
123		123
124	cmp [eax + sockets + 28], dword TCB_TIME_WAIT	124	cmp [eax + sockets + 28], dword TCB_TIME_WAIT
125	jne tth3	125	jne tth3
126		126
127	; OK, delete socket	127	; OK, delete socket
128	mov edi, eax	128	mov edi, eax
129	add edi, sockets	129	add edi, sockets
130		130
131	xor eax, eax	131	xor eax, eax
132	mov ecx, SOCKETHEADERSIZE	132	mov ecx, SOCKETHEADERSIZE
133	cld	133	cld
134	rep stosb	134	rep stosb
135		135
136	tth3:	136	tth3:
137	popa	137	popa
138		138
139	jmp tth1a	139	jmp tth1a
140		140
141	loop tth1	141	loop tth1
142	ret	142	ret
143		143
144	; TODO - prove it works!	144	; TODO - prove it works!
145	tth4:	145	tth4:
146	dec dword [eax + sockets + 72]	146	dec dword [eax + sockets + 72]
147	loop tth1	147	loop tth1
148	ret	148	ret
149		149
150		150
151		151
152		152
153	tth_exit:	153	tth_exit:
154	ret	154	ret
155		155
156		156
157	;***************************************************************************	157	;***************************************************************************
158	; Function	158	; Function
159	; tcp_tx_handler	159	; tcp_tx_handler
160	;	160	;
161	; Description	161	; Description
162	; Handles queued TCP data	162	; Handles queued TCP data
163	; This is a kernel function, called by stack_handler	163	; This is a kernel function, called by stack_handler
164	;	164	;
165	;***************************************************************************	165	;***************************************************************************
166	tcp_tx_handler:	166	tcp_tx_handler:
167	; decrement all resend buffers timers. If they	167	; decrement all resend buffers timers. If they
168	; expire, queue them for sending, and restart the timer.	168	; expire, queue them for sending, and restart the timer.
169	; If the retries counter reach 0, delete the entry	169	; If the retries counter reach 0, delete the entry
170		170
171	mov esi, resendQ	171	mov esi, resendQ
172	mov ecx, 0	172	mov ecx, 0
173		173
174	tth001:	174	tth001:
175	cmp ecx, NUMRESENDENTRIES	175	cmp ecx, NUMRESENDENTRIES
176	je tth003 ; None left	176	je tth003 ; None left
177	cmp [esi], byte 0xFF	177	cmp [esi], byte 0xFF
178	jne tth002 ; found one	178	jne tth002 ; found one
179	inc ecx	179	inc ecx
180	add esi, 4	180	add esi, 4
181	jmp tth001	181	jmp tth001
182		182
183	tth002:	183	tth002:
184	; we have one. decrement it's timer by 1	184	; we have one. decrement it's timer by 1
185	dec word [esi+2]	185	dec word [esi+2]
186	mov ax, [esi+2]	186	mov ax, [esi+2]
187	cmp ax, 0	187	cmp ax, 0
188	je tth002a	188	je tth002a
189	inc ecx	189	inc ecx
190	add esi, 4	190	add esi, 4
191	jmp tth001 ; Timer not zero, so move on	191	jmp tth001 ; Timer not zero, so move on
192		192
193	tth002a:	193	tth002a:
194	mov bl, 0xff	194	mov bl, 0xff
195	; restart timer, and decrement retries	195	; restart timer, and decrement retries
196	; After the first resend, back of on next, by a factor of 5	196	; After the first resend, back of on next, by a factor of 5
197	mov [esi+2], word TCP_TIMEOUT * 5	197	mov [esi+2], word TCP_TIMEOUT * 5
198	dec byte [esi+1]	198	dec byte [esi+1]
199	mov al, [esi+1]	199	mov al, [esi+1]
200	cmp al, 0	200	cmp al, 0
201	jne tth004	201	jne tth004
202		202
203	; retries now 0, so delete from queue	203	; retries now 0, so delete from queue
204	xchg [esi], bl	204	xchg [esi], bl
205	tth004:	205	tth004:
206		206
207	; resend packet	207	; resend packet
208	pusha	208	pusha
209		209
210	mov eax, EMPTY_QUEUE	210	mov eax, EMPTY_QUEUE
211	call dequeue	211	call dequeue
212	cmp ax, NO_BUFFER	212	cmp ax, NO_BUFFER
213	jne tth004z	213	jne tth004z
214		214
215	; TODO - try again in 10ms.	215	; TODO - try again in 10ms.
216	cmp bl, 0xff	216	cmp bl, 0xff
217	jne tth004za	217	jne tth004za
218	mov [esi], bl	218	mov [esi], bl
219		219
220	tth004za:	220	tth004za:
221	; Mark it to expire in 10ms - 1 tick	221	; Mark it to expire in 10ms - 1 tick
222	mov [esi+1], byte 1	222	mov [esi+1], byte 1
223	mov [esi+2], word 1	223	mov [esi+2], word 1
224	jmp tth005	224	jmp tth005
225		225
226	tth004z:	226	tth004z:
227	; we have a buffer # in ax	227	; we have a buffer # in ax
228		228
229	push eax	229	push eax
230	push ecx	230	push ecx
231	mov ecx, IPBUFFSIZE	231	mov ecx, IPBUFFSIZE
232	mul ecx	232	mul ecx
233	add eax, IPbuffs	233	add eax, IPbuffs
234		234
235	; we have the buffer address in eax	235	; we have the buffer address in eax
236	mov edi, eax	236	mov edi, eax
237	pop ecx	237	pop ecx
238	; get resend data address	238	; get resend data address
239	inc ecx	239	inc ecx
240	; Now get buffer location, and copy buffer across. argh! more copying,,	240	; Now get buffer location, and copy buffer across. argh! more copying,,
241	mov esi, resendBuffer - IPBUFFSIZE	241	mov esi, resendBuffer - IPBUFFSIZE
242	tth004a:	242	tth004a:
243	add esi, IPBUFFSIZE	243	add esi, IPBUFFSIZE
244	loop tth004a	244	loop tth004a
245		245
246	; we have resend buffer location in esi	246	; we have resend buffer location in esi
247	mov ecx, IPBUFFSIZE	247	mov ecx, IPBUFFSIZE
248		248
249	; copy data across	249	; copy data across
250	cld	250	cld
251	rep movsb	251	rep movsb
252		252
253	; queue packet	253	; queue packet
254		254
255		255
256		256
257	mov eax, NET1OUT_QUEUE	257	mov eax, NET1OUT_QUEUE
258		258
259	mov edx, [stack_ip]	259	mov edx, [stack_ip]
260	mov ecx, [ edi + 16 ]	260	mov ecx, [ edi + 16 ]
261	cmp edx, ecx	261	cmp edx, ecx
262	jne tth004b	262	jne tth004b
263	mov eax, IPIN_QUEUE	263	mov eax, IPIN_QUEUE
264		264
265	tth004b:	265	tth004b:
266	pop ebx	266	pop ebx
267		267
268	call queue	268	call queue
269		269
270		270
271	tth005:	271	tth005:
272	popa	272	popa
273		273
274	inc ecx	274	inc ecx
275	add esi, 4	275	add esi, 4
276	jmp tth001	276	jmp tth001
277		277
278	tth003:	278	tth003:
279	ret	279	ret
280		280
281		281
282		282
283		283
284	;***************************************************************************	284	;***************************************************************************
285	; Function	285	; Function
286	; tcp_rx	286	; tcp_rx
287	;	287	;
288	; Description	288	; Description
289	; TCP protocol handler	289	; TCP protocol handler
290	; This is a kernel function, called by ip_rx	290	; This is a kernel function, called by ip_rx
291	; IP buffer address given in edx	291	; IP buffer address given in edx
292	; IP buffer number in eax	292	; IP buffer number in eax
293	; Free up (or re-use) IP buffer when finished	293	; Free up (or re-use) IP buffer when finished
294	;	294	;
295	;***************************************************************************	295	;***************************************************************************
296	tcp_rx:	296	tcp_rx:
297	; The process is as follows.	297	; The process is as follows.
298	; Look for a socket with matching remote IP, remote port, local port	298	; Look for a socket with matching remote IP, remote port, local port
299	; if not found, then	299	; if not found, then
300	; look for remote IP + local port match ( where sockets remote port = 0)	300	; look for remote IP + local port match ( where sockets remote port = 0)
301	; if not found, then	301	; if not found, then
302	; look for a socket where local socket port == IP packets remote port	302	; look for a socket where local socket port == IP packets remote port
303	; where sockets remote port, remote IP = 0	303	; where sockets remote port, remote IP = 0
304	; discard if not found	304	; discard if not found
305	; Call sockets tcbStateMachine, with pointer to packet.	305	; Call sockets tcbStateMachine, with pointer to packet.
306	; the state machine will not delete the packet, so do that here.	306	; the state machine will not delete the packet, so do that here.
307		307
308	push eax	308	push eax
309		309
310	; Look for a socket where	310	; Look for a socket where
311	; IP Packet TCP Destination Port = local Port	311	; IP Packet TCP Destination Port = local Port
312	; IP Packet SA = Remote IP	312	; IP Packet SA = Remote IP
313	; IP Packet TCP Source Port = remote Port	313	; IP Packet TCP Source Port = remote Port
314		314
315	mov eax, SOCKETBUFFSIZE * NUM_SOCKETS	315	mov eax, SOCKETBUFFSIZE * NUM_SOCKETS
316	mov ecx, NUM_SOCKETS	316	mov ecx, NUM_SOCKETS
317	ss1:	317	ss1:
318	sub eax, SOCKETBUFFSIZE	318	sub eax, SOCKETBUFFSIZE
319	movzx ebx, word [edx + 22] ; get the dest. port from the TCP hdr	319	movzx ebx, word [edx + 22] ; get the dest. port from the TCP hdr
320	cmp [eax + sockets + 12], bx ; compare with socket's local port	320	cmp [eax + sockets + 12], bx ; compare with socket's local port
321	jnz nxttst1 ; different - try next socket	321	jnz nxttst1 ; different - try next socket
322		322
323	movzx ebx, word [edx + 20] ; get the source port from the TCP hdr	323	movzx ebx, word [edx + 20] ; get the source port from the TCP hdr
324	cmp [eax + sockets + 20], bx ; compare with socket's remote port	324	cmp [eax + sockets + 20], bx ; compare with socket's remote port
325	jnz nxttst1 ; different - try next socket	325	jnz nxttst1 ; different - try next socket
326		326
327		327
328	mov ebx, [edx + 12] ; get the source IP Addr from the IP hdr	328	mov ebx, [edx + 12] ; get the source IP Addr from the IP hdr
329	cmp [eax + sockets + 16], ebx ; compare with socket's remote IP	329	cmp [eax + sockets + 16], ebx ; compare with socket's remote IP
330	jnz nxttst1 ; different - try next socket	330	jnz nxttst1 ; different - try next socket
331		331
332	; We have a complete match - use this socket	332	; We have a complete match - use this socket
333	jmp tcprx_001	333	jmp tcprx_001
334		334
335	nxttst1:	335	nxttst1:
336	loop ss1 ; Return back if no match	336	loop ss1 ; Return back if no match
337		337
338	; If we got here, there was no match	338	; If we got here, there was no match
339	; Look for a socket where	339	; Look for a socket where
340	; IP Packet TCP Destination Port = local Port	340	; IP Packet TCP Destination Port = local Port
341	; IP Packet SA = Remote IP	341	; IP Packet SA = Remote IP
342	; socket remote Port = 0	342	; socket remote Port = 0
343		343
344	mov eax, SOCKETBUFFSIZE * NUM_SOCKETS	344	mov eax, SOCKETBUFFSIZE * NUM_SOCKETS
345	mov ecx, NUM_SOCKETS	345	mov ecx, NUM_SOCKETS
346		346
347	ss2:	347	ss2:
348	sub eax, SOCKETBUFFSIZE	348	sub eax, SOCKETBUFFSIZE
349		349
350	movzx ebx, word [edx + 22] ; get the dest. port from the TCP hdr	350	movzx ebx, word [edx + 22] ; get the dest. port from the TCP hdr
351	cmp [eax + sockets + 12], bx ; compare with socket's local port	351	cmp [eax + sockets + 12], bx ; compare with socket's local port
352	jnz nxttst2 ; different - try next socket	352	jnz nxttst2 ; different - try next socket
353		353
354	mov ebx, [edx + 12] ; get the source IP Addr from the IP hdr	354	mov ebx, [edx + 12] ; get the source IP Addr from the IP hdr
355	cmp [eax + sockets + 16], ebx ; compare with socket's remote IP	355	cmp [eax + sockets + 16], ebx ; compare with socket's remote IP
356	jnz nxttst2 ; different - try next socket	356	jnz nxttst2 ; different - try next socket
357		357
358	mov ebx, 0	358	mov ebx, 0
359	cmp [eax + sockets + 20], bx ; only match a remote socket of 0	359	cmp [eax + sockets + 20], bx ; only match a remote socket of 0
360	jnz nxttst2 ; different - try next socket	360	jnz nxttst2 ; different - try next socket
361		361
362	; We have a complete match - use this socket	362	; We have a complete match - use this socket
363	jmp tcprx_001	363	jmp tcprx_001
364		364
365	nxttst2:	365	nxttst2:
366	loop ss2 ; Return back if no match	366	loop ss2 ; Return back if no match
367		367
368	; If we got here, there was no match	368	; If we got here, there was no match
369	; Look for a socket where	369	; Look for a socket where
370	; IP Packet TCP Destination Port = local Port	370	; IP Packet TCP Destination Port = local Port
371	; socket Remote IP = 0	371	; socket Remote IP = 0
372	; socket remote Port = 0	372	; socket remote Port = 0
373		373
374	mov eax, SOCKETBUFFSIZE * NUM_SOCKETS	374	mov eax, SOCKETBUFFSIZE * NUM_SOCKETS
375	mov ecx, NUM_SOCKETS	375	mov ecx, NUM_SOCKETS
376		376
377	ss3:	377	ss3:
378	sub eax, SOCKETBUFFSIZE	378	sub eax, SOCKETBUFFSIZE
379		379
380	movzx ebx, word [edx + 22] ; get destination port from the TCP hdr	380	movzx ebx, word [edx + 22] ; get destination port from the TCP hdr
381	cmp [eax + sockets + 12], bx ; compare with socket's local port	381	cmp [eax + sockets + 12], bx ; compare with socket's local port
382	jnz nxttst3 ; different - try next socket	382	jnz nxttst3 ; different - try next socket
383		383
384	mov ebx, 0	384	mov ebx, 0
385	cmp [eax + sockets + 20], bx ; only match a remote socket of 0	385	cmp [eax + sockets + 20], bx ; only match a remote socket of 0
386	jnz nxttst3 ; different - try next socket	386	jnz nxttst3 ; different - try next socket
387		387
388	mov ebx, 0	388	mov ebx, 0
389	cmp [eax + sockets + 16], ebx ; only match a socket remote IP of 0	389	cmp [eax + sockets + 16], ebx ; only match a socket remote IP of 0
390	jnz nxttst3 ; different - try next socket	390	jnz nxttst3 ; different - try next socket
391		391
392	; We have a complete match - use this socket	392	; We have a complete match - use this socket
393	jmp tcprx_001	393	jmp tcprx_001
394		394
395	nxttst3:	395	nxttst3:
396	loop ss3 ; Return back if no match	396	loop ss3 ; Return back if no match
397		397
398	; If we got here, we need to reject the packet	398	; If we got here, we need to reject the packet
399	inc dword [dumped_rx_count]	399	inc dword [dumped_rx_count]
400	jmp tcprx_exit	400	jmp tcprx_exit
401		401
402	tcprx_001:	402	tcprx_001:
403	; We have a valid socket/TCB, so call the TCB State Machine for that skt.	403	; We have a valid socket/TCB, so call the TCB State Machine for that skt.
404	; socket is pointed to by [eax + sockets]	404	; socket is pointed to by [eax + sockets]
405	; IP packet is pointed to by [edx]	405	; IP packet is pointed to by [edx]
406	; IP buffer number is on stack ( it will be popped at the end)	406	; IP buffer number is on stack ( it will be popped at the end)
407	call tcpStateMachine	407	call tcpStateMachine
408		408
409	tcprx_exit:	409	tcprx_exit:
410	pop eax	410	pop eax
411	call freeBuff	411	call freeBuff
412		412
413	ret	413	ret
414		414
415		415
416		416
417	;***************************************************************************	417	;***************************************************************************
418	; Function	418	; Function
419	; buildTCPPacket	419	; buildTCPPacket
420	;	420	;
421	; Description	421	; Description
422	; builds an IP Packet with TCP data fully populated for transmission	422	; builds an IP Packet with TCP data fully populated for transmission
423	; You may destroy any and all registers	423	; You may destroy any and all registers
424	; TCP control flags specified in bl	424	; TCP control flags specified in bl
425	; This TCB is in [sktAddr]	425	; This TCB is in [sktAddr]
426	; User data pointed to by esi	426	; User data pointed to by esi
427	; Data length in ecx	427	; Data length in ecx
428	; Transmit buffer number in eax	428	; Transmit buffer number in eax
429	;	429	;
430	;***************************************************************************	430	;***************************************************************************
431	buildTCPPacket:	431	buildTCPPacket:
432	push ecx ; Save data length	432	push ecx ; Save data length
433		433
434	; convert buffer pointer eax to the absolute address	434	; convert buffer pointer eax to the absolute address
435	mov ecx, IPBUFFSIZE	435	mov ecx, IPBUFFSIZE
436	mul ecx	436	mul ecx
437	add eax, IPbuffs	437	add eax, IPbuffs
438		438
439	mov edx, eax	439	mov edx, eax
440		440
441	mov [edx + 33], bl ; TCP flags	441	mov [edx + 33], bl ; TCP flags
442		442
443	mov ebx, [sktAddr]	443	mov ebx, [sktAddr]
444		444
445	; So, ebx holds the socket ptr, edx holds the IPbuffer ptr	445	; So, ebx holds the socket ptr, edx holds the IPbuffer ptr
446		446
447	; Fill in the IP header ( some data is in the socket descriptor)	447	; Fill in the IP header ( some data is in the socket descriptor)
448	mov eax, [ebx + 8]	448	mov eax, [ebx + 8]
449	mov [edx + 12], eax ; source IP	449	mov [edx + 12], eax ; source IP
450	mov eax, [ebx + 16]	450	mov eax, [ebx + 16]
451	mov [edx + 16], eax ; Destination IP	451	mov [edx + 16], eax ; Destination IP
452		452
453	mov al, 0x45	453	mov al, 0x45
454	mov [edx], al ; Version, IHL	454	mov [edx], al ; Version, IHL
455	xor al, al	455	xor al, al
456	mov [edx + 1], al ; Type of service	456	mov [edx + 1], al ; Type of service
457		457
458	pop eax ; Get the TCP data length	458	pop eax ; Get the TCP data length
459	push eax	459	push eax
460		460
461	add eax, 20 + 20 ; add IP header and TCP header lengths	461	add eax, 20 + 20 ; add IP header and TCP header lengths
462	mov [edx + 2], ah	462	mov [edx + 2], ah
463	mov [edx + 3], al	463	mov [edx + 3], al
464	xor al, al	464	xor al, al
465	mov [edx + 4], al	465	mov [edx + 4], al
466	mov [edx + 5], al	466	mov [edx + 5], al
467	mov al, 0x40	467	mov al, 0x40
468	mov [edx + 6], al	468	mov [edx + 6], al
469	xor al, al	469	xor al, al
470	mov [edx + 7], al	470	mov [edx + 7], al
471	mov al, 0x20	471	mov al, 0x20
472	mov [edx + 8], al	472	mov [edx + 8], al
473	mov al, 6 ; TCP protocol	473	mov al, 6 ; TCP protocol
474	mov [edx + 9], al	474	mov [edx + 9], al
475		475
476	; Checksum left unfilled	476	; Checksum left unfilled
477	xor ax, ax	477	xor ax, ax
478	mov [edx + 10], ax	478	mov [edx + 10], ax
479		479
480	; Fill in the TCP header ( some data is in the socket descriptor)	480	; Fill in the TCP header ( some data is in the socket descriptor)
481	mov ax, [ebx + 12]	481	mov ax, [ebx + 12]
482	mov [edx + 20], ax ; Local Port	482	mov [edx + 20], ax ; Local Port
483		483
484	mov ax, [ebx + 20]	484	mov ax, [ebx + 20]
485	mov [edx + 20 + 2], ax ; desitination Port	485	mov [edx + 20 + 2], ax ; desitination Port
486		486
487	; Checksum left unfilled	487	; Checksum left unfilled
488	xor ax, ax	488	xor ax, ax
489	mov [edx + 20 + 16], ax	489	mov [edx + 20 + 16], ax
490		490
491	; sequence number	491	; sequence number
492	mov eax, [ebx + 48]	492	mov eax, [ebx + 48]
493	mov [edx + 20 + 4], eax	493	mov [edx + 20 + 4], eax
494		494
495	; ack number	495	; ack number
496	mov eax, [ebx + 56]	496	mov eax, [ebx + 56]
497	mov [edx + 20 + 8], eax	497	mov [edx + 20 + 8], eax
498		498
499	; window ( 0x2000 is default ).I could accept 4KB, fa0, ( skt buffer size)	499	; window ( 0x2000 is default ).I could accept 4KB, fa0, ( skt buffer size)
500	; 768 bytes seems better	500	; 768 bytes seems better

Subversion Repositories Kolibri OS

(root)/kernel/trunk/network/tcp.inc – Rev 261 → 379