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

Subversion Repositories Kolibri OS

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