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


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/network/tcp.inc – Rev 380 → 425