WebSVN – Kolibri OS – Diff – /kernel/branches/kolibri_pe/network/tcp.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;  TCP.INC                                                     ;;
;;                                                              ;;
;;  TCP Processes for Menuet OS  TCP/IP stack                   ;;
;;                                                              ;;
 
 
;;  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                             ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 2971 $
 
 
; 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_TIMED_WAIT	   equ	      10
TCB_CLOSED         equ        11
 
TH_FIN	= 0x01
TH_SYN	= 0x02
TH_RST	= 0x04
TH_PUSH = 0x08
TH_ACK	= 0x10
TH_URG	= 0x20
 
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
;
;***************************************************************************
 
proc tcp_tcb_handler stdcall uses ebx
    ; scan through all the sockets, decrementing active timers
 
	mov	ebx, net_sockets
 
	cmp	[ebx + SOCKET.NextPtr], 0
	je	.exit
	;DEBUGF	1, "K : sockets:\n"
 
  .next_socket:
	mov	ebx, [ebx + SOCKET.NextPtr]
	or	ebx, ebx
	jz	.exit
 
	;DEBUGF	1, "K :   %x-%x: %x-%x-%x-%u\n", [ebx + SOCKET.PID]:2, [ebx + SOCKET.Number]:2, [ebx + SOCKET.LocalPort]:4, [ebx + SOCKET.RemoteIP], [ebx + SOCKET.RemotePort]:4, [ebx + SOCKET.TCBState]
 
	cmp	[ebx + SOCKET.TCBTimer], 0
	jne	.decrement_tcb
	cmp	[ebx + SOCKET.wndsizeTimer], 0
	jne	.decrement_wnd
	jmp	.next_socket
 
  .decrement_tcb:
    ; decrement it, delete socket if TCB timer = 0 & socket in timewait state
	dec	[ebx + SOCKET.TCBTimer]
	jnz	.next_socket
 
	cmp	[ebx + SOCKET.TCBState], TCB_TIMED_WAIT
	jne	.next_socket
 
	push	[ebx + SOCKET.PrevPtr]
	stdcall net_socket_free, ebx
	pop	ebx
	jmp	.next_socket
 
  .decrement_wnd:
    ; TODO - prove it works!
	dec	[ebx + SOCKET.wndsizeTimer]
	jmp	.next_socket
 
  .exit:
    ret
endp
 
 
;***************************************************************************
;   Function
;      tcp_tx_handler
;
;   Description
;       Handles queued TCP data
;       This is a kernel function, called by stack_handler
;
;***************************************************************************
 
proc tcp_tx_handler stdcall
    ; 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
 
  .next_resendq:
    cmp     ecx, NUMRESENDENTRIES
	je	.exit		    ; None left
 
	cmp	dword[esi + 4], 0
	jne	@f		     ; found one
    inc     ecx
	add	esi, 8
	jmp	.next_resendq
 
    @@: ; we have one. decrement it's timer by 1
	dec	word[esi + 2]
	jz	@f
    inc     ecx
	add	esi, 8
	jmp	.next_resendq	    ; Timer not zero, so move on
 
    @@:
 
	xor	ebx, ebx
    ; 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]
	jnz	@f
 
    ; retries now 0, so delete from queue
 
	xchg	 [esi + 4], ebx
 
    @@: ; resend packet
	pushad
 
    mov     eax, EMPTY_QUEUE
    call    dequeue
    cmp     ax, NO_BUFFER
	jne	.tth004z
 
    ; TODO - try again in 10ms.
 
	test	ebx, ebx
	jnz	@f
 
	mov	[esi + 4], ebx
 
    @@: ; Mark it to expire in 10ms - 1 tick
	mov	byte[esi + 1], 1
	mov	word[esi + 2], 1
	jmp	.tth005
 
  .tth004z:
    ; we have a buffer # in ax
 
	push	eax ecx
    mov     ecx, IPBUFFSIZE
    mul     ecx
    add     eax, IPbuffs
 
    ; we have the buffer address in eax
    mov     edi, eax
    pop     ecx
    ; Now get buffer location, and copy buffer across. argh! more copying,,
	mov	esi, resendBuffer
    @@: add	esi, IPBUFFSIZE
	loop	@b
 
    ; we have resend buffer location in esi
    mov     ecx, IPBUFFSIZE
 
    ; copy data across
	push	edi
    cld
    rep     movsb
	pop	edi
 
    ; queue packet
 
 
 
    mov     eax, NET1OUT_QUEUE
 
    mov     edx, [stack_ip]
	cmp	edx, [edi + IP_PACKET.DestinationAddress]
	jne	.not_local
    mov     eax, IPIN_QUEUE
 
  .not_local:
    pop     ebx
 
    call    queue
 
  .tth005:
	popad
 
    inc     ecx
	add	esi, 8
	jmp	.next_resendq
 
  .exit:
    ret
endp
 
 
;***************************************************************************
;   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
;
;***************************************************************************
 
proc tcp_rx stdcall uses ebx
    ; 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	ebx, net_sockets
 
  .next_socket.1:
	mov	ebx, [ebx + SOCKET.NextPtr]
	or	ebx, ebx
	jz	.next_socket.1.exit
 
 
 
 
;        DEBUGF  1, "K : tcp_rx - 1.dport: %x - %x\n", [edx + 20 + TCP_PACKET.DestinationPort]:4, [ebx + SOCKET.LocalPort]:4
 
	mov	ax, [edx + 20 + TCP_PACKET.DestinationPort]  ; get the dest. port from the TCP hdr
	cmp	[ebx + SOCKET.LocalPort], ax		; get the dest. port from the TCP hdr
	jne	.next_socket.1				; different - try next socket
 
;        DEBUGF  1, "K : tcp_rx - 1.addr: %x - %x\n", [edx + IP_PACKET.SourceAddress], [ebx + SOCKET.RemoteIP]
 
	mov	eax, [edx + IP_PACKET.SourceAddress]	; get the source IP Addr from the IP hdr
	cmp	[ebx + SOCKET.RemoteIP], eax		; compare with socket's remote IP
	jne	.next_socket.1				; different - try next socket
 
;        DEBUGF  1, "K : tcp_rx - 1.sport: %x - %x\n", [edx + 20 + TCP_PACKET.SourcePort]:4, [ebx + SOCKET.RemotePort]:4
 
	mov	ax, [edx + 20 + TCP_PACKET.SourcePort]	; get the source port from the TCP hdr
	cmp	[ebx + SOCKET.RemotePort], ax		; compare with socket's remote port
	jne	.next_socket.1				; different - try next socket
 
    ; We have a complete match - use this socket
	jmp	.change_state
 
  .next_socket.1.exit:
 
    ; 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	ebx, net_sockets
 
  .next_socket.2:
	mov	ebx, [ebx + SOCKET.NextPtr]
	or	ebx, ebx
	jz	.next_socket.2.exit
 
 
 
 
;        DEBUGF  1, "K : tcp_rx - 2.dport: %x - %x\n", [edx + 20 + TCP_PACKET.DestinationPort]:4, [ebx + SOCKET.LocalPort]:4
 
	mov	ax, [edx + 20 + TCP_PACKET.DestinationPort]  ; get the dest. port from the TCP hdr
	cmp	[ebx + SOCKET.LocalPort], ax		; compare with socket's local port
	jne	.next_socket.2				; different - try next socket
 
;        DEBUGF  1, "K : tcp_rx - 2.addr: %x - %x\n", [edx + IP_PACKET.SourceAddress], [ebx + SOCKET.RemoteIP]
 
	mov	eax, [edx + IP_PACKET.SourceAddress]	; get the source IP Addr from the IP hdr
	cmp	[ebx + SOCKET.RemoteIP], eax		; compare with socket's remote IP
	jne	.next_socket.2				; different - try next socket
 
;        DEBUGF  1, "K : tcp_rx - 2.sport: 0000 - %x\n", [ebx + SOCKET.RemotePort]:4
 
	cmp	[ebx + SOCKET.RemotePort], 0		; only match a remote socket of 0
	jne	.next_socket.2				; different - try next socket
 
    ; We have a complete match - use this socket
	jmp	.change_state
 
  .next_socket.2.exit:
 
    ; 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	ebx, net_sockets
 
  .next_socket.3:
	mov	ebx, [ebx + SOCKET.NextPtr]
	or	ebx, ebx
	jz	.next_socket.3.exit
 
 
 
 
;        DEBUGF  1, "K : tcp_rx - 3.dport: %x - %x\n", [edx + 20 + TCP_PACKET.DestinationPort]:4, [ebx + SOCKET.LocalPort]:4
 
	mov	ax, [edx + 20 + TCP_PACKET.DestinationPort]  ; get destination port from the TCP hdr
	cmp	[ebx + SOCKET.LocalPort], ax		; compare with socket's local port
	jne	.next_socket.3				; different - try next socket
 
;        DEBUGF  1, "K : tcp_rx - 3.addr: 00000000 - %x\n", [ebx + SOCKET.RemoteIP]
 
	cmp	[ebx + SOCKET.RemoteIP], 0		; only match a socket remote IP of 0
	jne	.next_socket.3				; different - try next socket
 
;        DEBUGF  1, "K : tcp_rx - 3.sport: 0000 - %x\n", [ebx + SOCKET.RemotePort]:4
 
	cmp	[ebx + SOCKET.RemotePort], 0		; only match a remote socket of 0
	jne	.next_socket.3				; different - try next socket
 
    ; We have a complete match - use this socket
	jmp	.change_state
 
  .next_socket.3.exit:
 
    ; If we got here, we need to reject the packet
 
	DEBUGF	1, "K : tcp_rx - dumped\n"
	DEBUGF	1, "K :   --------: %x-%x-%x (flags: %x)\n", [edx + 20 + TCP_PACKET.DestinationPort]:4, [edx + IP_PACKET.SourceAddress], [edx + 20 + TCP_PACKET.SourcePort]:4, [edx + 20 + TCP_PACKET.Flags]:2
 
 
 
 
 
 
 
 
 
 
	inc	[dumped_rx_count]
	jmp	.exit
 
  .change_state:
 
    ; We have a valid socket/TCB, so call the TCB State Machine for that skt.
	; socket is pointed to by ebx
	; IP packet is pointed to by edx
    ; IP buffer number is on stack ( it will be popped at the end)
 
	stdcall tcpStateMachine, ebx
 
  .exit:
    pop     eax
    call    freeBuff
 
    ret
endp
 
 
;***************************************************************************
;   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
;
;***************************************************************************
 
proc build_tcp_packet stdcall, sockAddr:DWORD
    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 + 20 + TCP_PACKET.Flags], bl		; TCP flags
 
	mov	ebx, [sockAddr]
 
    ; 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 + SOCKET.LocalIP]
	mov	[edx + IP_PACKET.SourceAddress], eax
	mov	eax, [ebx + SOCKET.RemoteIP]
	mov	[edx + IP_PACKET.DestinationAddress], eax
 
	mov	[edx + IP_PACKET.VersionAndIHL], 0x45
	mov	[edx + IP_PACKET.TypeOfService], 0
 
    pop     eax                   ; Get the TCP data length
    push    eax
 
    add     eax, 20 + 20           ; add IP header and TCP header lengths
	rol	ax, 8
	mov	[edx + IP_PACKET.TotalLength], ax
	mov	[edx + IP_PACKET.Identification], 0
	mov	[edx + IP_PACKET.FlagsAndFragmentOffset], 0x0040
	mov	[edx + IP_PACKET.TimeToLive], 0x20
	mov	[edx + IP_PACKET.Protocol], PROTOCOL_TCP
 
    ; Checksum left unfilled
	mov	[edx + IP_PACKET.HeaderChecksum], 0
 
	; Fill in the TCP header (some data is in the socket descriptor)
	mov	ax, [ebx + SOCKET.LocalPort]
	mov	[edx + 20 + TCP_PACKET.SourcePort], ax		; Local Port
 
	mov	ax, [ebx + SOCKET.RemotePort]
	mov	[edx + 20 + TCP_PACKET.DestinationPort], ax	; desitination Port
 
    ; Checksum left unfilled
	mov	[edx + 20 + TCP_PACKET.Checksum], 0
 
    ; sequence number
	mov	eax, [ebx + SOCKET.SND_NXT]
	mov	[edx + 20 + TCP_PACKET.SequenceNumber], eax
 
    ; ack number
	mov	eax, [ebx + SOCKET.RCV_NXT]
	mov	[edx + 20 + TCP_PACKET.AckNumber], eax
 
    ; window ( 0x2000 is default ).I could accept 4KB, fa0, ( skt buffer size)
    ; 768 bytes seems better
	mov	[edx + 20 + TCP_PACKET.Window], 0x0003
 
    ; Urgent pointer (0)
	mov	[edx + 20 + TCP_PACKET.UrgentPointer], 0
 
    ; data offset ( 0x50 )
	mov	[edx + 20 + TCP_PACKET.DataOffset], 0x50
 
    pop     ecx                  ; count of bytes to send
    mov     ebx, ecx            ; need the length later
 
    cmp     ebx, 0
	jz	@f
 
    mov     edi, edx
    add     edi, 40
    cld
    rep     movsb               ; copy the data across
 
    @@: ; we have edx as IPbuffer ptr.
    ; Fill in the TCP checksum
    ; First, fill in pseudoheader
	mov	eax, [edx + IP_PACKET.SourceAddress]
    mov     [pseudoHeader], eax
	mov	eax, [edx + IP_PACKET.DestinationAddress]
	mov	[pseudoHeader + 4], eax
	mov	word[pseudoHeader + 8], PROTOCOL_TCP shl 8 + 0
    add     ebx, 20
	mov	[pseudoHeader + 10], bh
	mov	[pseudoHeader + 11], bl
 
    mov     eax, pseudoHeader
    mov     [checkAdd1], eax
	mov	word[checkSize1], 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]
	rol	ax, 8
	mov	[edx + 20 + TCP_PACKET.Checksum], ax
 
    ; Fill in the IP header checksum
	GET_IHL eax, edx	       ; get IP-Header length
	stdcall checksum_jb, edx, eax  ; buf_ptr, buf_size
	rol	ax, 8
	mov	[edx + IP_PACKET.HeaderChecksum], ax
 
    ret
endp
 
 
; Increments the 32 bit value pointed to by esi in internet order
proc inc_inet_esi stdcall
    push    eax
	mov	eax, [esi]
	bswap	eax
	inc	eax
	bswap	eax
	mov	[esi], eax
    pop     eax
    ret
endp
 
 
; Increments the 32 bit value pointed to by esi in internet order
; by the value in ecx
proc add_inet_esi stdcall
    push    eax
	mov	eax, [esi]
	bswap	eax
    add     eax, ecx
	bswap	eax
	mov	[esi], eax
    pop     eax
    ret
endp
 
 
iglobal
  TCBStateHandler dd \
    stateTCB_LISTEN, \
    stateTCB_SYN_SENT, \
    stateTCB_SYN_RECEIVED, \
    stateTCB_ESTABLISHED, \
    stateTCB_FIN_WAIT_1, \
    stateTCB_FIN_WAIT_2, \
    stateTCB_CLOSE_WAIT, \
    stateTCB_CLOSING, \
    stateTCB_LAST_ACK, \
    stateTCB_TIME_WAIT, \
    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 ebx
;
;       The IP buffer will be released by the caller
;***************************************************************************
 
proc tcpStateMachine stdcall, sockAddr:DWORD
    ; as a packet has been received, update the TCB timer
	mov	[ebx + SOCKET.TCBTimer], TWOMSL
 
    ; If the received packet has an ACK bit set,
    ; remove any packets in the resend queue that this
    ; received packet acknowledges
	pushad
	test	[edx + 20 + TCP_PACKET.Flags], TH_ACK
	jz	.call_handler					; No ACK, so no data yet
 
	; get skt number in eax
	stdcall net_socket_addr_to_num, ebx
 
    ; The ack number is in [edx + 28], inet format
	; skt in eax
 
    mov     esi, resendQ
	xor	ecx, ecx
 
  .next_resendq:
    cmp     ecx, NUMRESENDENTRIES
	je	.call_handler	  ; None left
 
	cmp	[esi + 4], eax
	je	@f		  ; found one
    inc     ecx
	add	esi, 8
	jmp	.next_resendq
 
    @@: 		  ; Can we delete this buffer?
 
			  ; If yes, goto @@. No, goto .next_resendq
    ; Get packet data address
 
    push    ecx
    ; Now get buffer location, and copy buffer across. argh! more copying,,
	imul	edi, ecx, IPBUFFSIZE
	add	edi, resendBuffer
 
    ; we have dest buffer location in edi. incoming packet in edx.
    ; Get this packets sequence number
    ; preserve al, ecx, esi, edx
	mov	ecx, [edi + 20 + TCP_PACKET.SequenceNumber]
	bswap	ecx
	movzx	ebx, word[edi + 2]
	xchg	bl, bh
    sub     ebx, 40
    add     ecx, ebx          ; ecx is now seq# of last byte +1, intel format
 
    ; get recievd ack #, in intel format
	mov	ebx, [edx + 20 + TCP_PACKET.AckNumber]
	bswap	ebx
 
    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	@f		; if rx > old, delete old
 
    inc     ecx
	add	esi, 8
	jmp	.next_resendq
 
 
    @@: mov	dword[esi + 4], 0
    inc     ecx
	add	esi, 8
	jmp	.next_resendq
 
  .call_handler:
	popad
 
    ; Call handler for given TCB state
 
	mov	eax, [ebx + SOCKET.TCBState]
	cmp	eax, TCB_LISTEN
	jb	.exit
	cmp	eax, TCB_CLOSED
	ja	.exit
 
	stdcall [TCBStateHandler + (eax - 1) * 4], [sockAddr]
 
  .exit:
    ret
endp
 
 
proc stateTCB_LISTEN stdcall, sockAddr:DWORD
    ; 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
	test	[edx + 20 + TCP_PACKET.Flags], TH_SYN
	jz	.exit
 
    ; We have a SYN. update the socket with this IP packets details,
    ; And send a response
 
	mov	eax, [edx + IP_PACKET.SourceAddress]
	mov	[ebx + SOCKET.RemoteIP], eax
	mov	ax, [edx + 20 + TCP_PACKET.SourcePort]
	mov	[ebx + SOCKET.RemotePort], ax
	mov	eax, [edx + 20 + TCP_PACKET.SequenceNumber]
	mov	[ebx + SOCKET.IRS], eax
	mov	[ebx + SOCKET.RCV_NXT], eax
	lea	esi, [ebx + SOCKET.RCV_NXT]
    call    inc_inet_esi ; RCV.NXT
	mov	eax, [ebx + SOCKET.ISS]
	mov	[ebx + SOCKET.SND_NXT], eax
 
    ; Now construct the response, and queue for sending by IP
    mov     eax, EMPTY_QUEUE
    call    dequeue
    cmp     ax, NO_BUFFER
	je	.exit
 
    push    eax
	mov	bl, TH_SYN + TH_ACK
	xor	ecx, ecx
	xor	esi, esi
	stdcall build_tcp_packet, [sockAddr]
 
    mov     eax, NET1OUT_QUEUE
    mov     edx, [stack_ip]
	mov	ecx, [sockAddr]
	cmp	edx, [ecx + SOCKET.RemoteIP]
	jne	.not_local
    mov     eax, IPIN_QUEUE
 
  .not_local:
       ; Send it.
    pop     ebx
    call    queue
 
	mov	esi, [sockAddr]
	mov	[esi + SOCKET.TCBState], TCB_SYN_RECEIVED
 
	; increment SND.NXT in socket
	add	esi, SOCKET.SND_NXT
    call    inc_inet_esi
 
  .exit:
    ret
endp
 
 
proc stateTCB_SYN_SENT stdcall, sockAddr:DWORD
    ; We are awaiting an ACK to our SYN, with a SYM
    ; Look at control flags - expecting an ACK
 
	mov	al, [edx + 20 + TCP_PACKET.Flags]
	and	al, TH_SYN + TH_ACK
	cmp	al, TH_SYN + TH_ACK
	je	.syn_ack
 
	test	al, TH_SYN
	jz	.exit
 
	mov	[ebx + SOCKET.TCBState], TCB_SYN_RECEIVED
	push	TH_SYN + TH_ACK
	jmp	.send
 
  .syn_ack:
	mov	[ebx + SOCKET.TCBState], TCB_ESTABLISHED
	push	TH_ACK
 
  .send:
    ; Store the recv.nxt field
	mov	eax, [edx + 20 + TCP_PACKET.SequenceNumber]
 
    ; Update our recv.nxt field
	mov	[ebx + SOCKET.RCV_NXT], eax
	lea	esi, [ebx + SOCKET.RCV_NXT]
    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
	pop	ebx
	je	.exit
 
    push    eax
 
	xor	ecx, ecx
	xor	esi, esi
	stdcall build_tcp_packet, [sockAddr]
 
    mov     eax, NET1OUT_QUEUE
 
    mov     edx, [stack_ip]
	mov	ecx, [sockAddr]
	cmp	edx, [ecx + SOCKET.RemoteIP]
	jne	.not_local
    mov     eax, IPIN_QUEUE
 
  .not_local:
       ; Send it.
    pop     ebx
    call    queue
 
  .exit:
    ret
endp
 
 
proc stateTCB_SYN_RECEIVED stdcall, sockAddr:DWORD
    ; In this case, we are expecting an ACK packet
    ; For now, if the packet is an ACK, process it,
    ; If not, ignore it
 
	test	[edx + 20 + TCP_PACKET.Flags], TH_RST
	jz	.check_ack
 
	push	[ebx + SOCKET.OrigRemotePort] [ebx + SOCKET.OrigRemoteIP]
	pop	[ebx + SOCKET.RemoteIP] [ebx + SOCKET.RemotePort]
 
	mov	[ebx + SOCKET.TCBState], TCB_LISTEN
	jmp	.exit
 
  .check_ack:
    ; Look at control flags - expecting an ACK
	test	[edx + 20 + TCP_PACKET.Flags], TH_ACK
	jz	.exit
 
	mov	[ebx + SOCKET.TCBState], TCB_ESTABLISHED
 
  .exit:
    ret
endp
 
 
proc stateTCB_ESTABLISHED stdcall, sockAddr:DWORD
    ; Here we are expecting data, or a request to close
    ; OR both...
 
    ; Did we receive a FIN or RST?
 
 
	test	[edx + 20 + TCP_PACKET.Flags], TH_FIN
	jz	.check_ack
 
    ; It was a fin or reset.
 
    ; Remove resend entries from the queue  - I dont want to send any more data
	pushad
 
	; get skt #
	stdcall net_socket_addr_to_num, ebx
 
    mov     esi, resendQ
    mov     ecx, 0
 
  .next_resendq:
    cmp     ecx, NUMRESENDENTRIES
	je	.last_resendq	    ; None left
 
	cmp	[esi + 4], eax
	je	@f		    ; found one
	inc	ecx
	add	esi, 8
	jmp	.next_resendq
 
 
    @@: mov	dword[esi + 4], 0
    inc     ecx
	add	esi, 8
	jmp	.next_resendq
 
  .last_resendq:
	popad
 
 
 
 
 
 
 
 
    @@: ; Send an ACK to that fin, and enter closewait state
 
	mov	[ebx + SOCKET.TCBState], TCB_CLOSE_WAIT
	lea	esi, [ebx + SOCKET.RCV_NXT]
    mov     eax, [esi]              ; save original
    call    inc_inet_esi
    ;; jmp    ste_ack - NO, there may be data
 
  .check_ack:
    ; Check that we received an ACK
	test	[edx + 20 + TCP_PACKET.Flags], TH_ACK
	jz	.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	cx, [edx + 20 + TCP_PACKET.Window]
	xchg	cl, ch
    cmp     cx, 1024
	ja	@f
 
	mov	[ebx + SOCKET.wndsizeTimer], 1
 
    @@: ; 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 inet format
    ; recv seq is in [sktAddr]+56, in inet format
    ; just do a comparision
	mov	ecx, [ebx + SOCKET.RCV_NXT]
	cmp	[ebx + SOCKET.TCBState], TCB_CLOSE_WAIT
	jne	@f
    mov     ecx, eax
 
    @@: cmp	ecx, [edx + 20 + TCP_PACKET.SequenceNumber]
	jne	.ack
 
 
    ; Read the data bytes, store in socket buffer
	movzx	ecx, [edx + IP_PACKET.TotalLength]
	xchg	cl, ch
    sub     ecx, 40                    ; Discard 40 bytes of header
	ja	.data			   ; Read data, if any
 
    ; If we had received a fin, we need to ACK it.
	cmp	[ebx + SOCKET.TCBState], TCB_CLOSE_WAIT
	je	.ack
	jmp	.exit
 
  .data:
	push	ebx
 
	add	ebx, SOCKET.lock
	call	wait_mutex
	pop	ebx
 
	push	ecx
	push	[ebx + SOCKET.PID]	; get socket owner PID
	mov	eax, [ebx + SOCKET.rxDataCount]
	add	eax, ecx
	cmp	eax, SOCKETBUFFSIZE - SOCKETHEADERSIZE
	ja	.overflow
 
	mov	[ebx + SOCKET.rxDataCount], eax      ; increment the count of bytes in buffer
 
    ; point to the location to store the data
	lea	edi, [ebx + eax + SOCKETHEADERSIZE]
	sub	edi, ecx
 
    add     edx, 40        ; edx now points to the data
    mov     esi, edx
 
    cld
    rep     movsb          ; copy the data across
	mov	[ebx + SOCKET.lock], 0	; release mutex
 
    ; flag an event to the application
    pop     eax
	mov	ecx, 1
	mov	esi, TASK_DATA + TASKDATA.pid
 
  .next_pid:
	cmp	[esi], eax
	je	.found_pid
    inc     ecx
	add	esi, 0x20
	cmp	ecx, [TASK_COUNT]
	jbe	.next_pid
 
  .found_pid:
	shl	ecx, 8
	or	[ecx + SLOT_BASE + APPDATA.event_mask], EVENT_NETWORK ; stack event
 
    pop     ecx
 
    ; Update our recv.nxt field
	lea	esi, [ebx + SOCKET.RCV_NXT]
    call    add_inet_esi
 
  .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	.exit
 
    push    eax
 
	mov	bl, TH_ACK
	xor	ecx, ecx
	xor	esi, esi
	stdcall build_tcp_packet, [sockAddr]
 
    mov     eax, NET1OUT_QUEUE
 
    mov     edx, [stack_ip]
	mov	ecx, [sockAddr]
	cmp	edx, [ecx + SOCKET.RemoteIP]
	jne	.not_local
    mov     eax, IPIN_QUEUE
 
  .not_local:
       ; Send it.
    pop     ebx
    call    queue
 
  .exit:
    ret
  .overflow:
	; no place in buffer
	; so simply restore stack and exit
	pop	eax ecx
	mov	[ebx + SOCKET.lock], 0
	ret
endp
 
 
proc stateTCB_FIN_WAIT_1 stdcall, sockAddr:DWORD
    ; We can either receive an ACK of a fin, or a fin
	mov	al, [edx + 20 + TCP_PACKET.Flags]
	and	al, TH_FIN + TH_ACK
 
	cmp	al, TH_ACK
	jne	@f
 
    ; It was an ACK
	mov	[ebx + SOCKET.TCBState], TCB_FIN_WAIT_2
	jmp	.exit
 
    @@: mov	[ebx + SOCKET.TCBState], TCB_CLOSING
	cmp	al, TH_FIN
	je	@f
	mov	[ebx + SOCKET.TCBState], TCB_TIMED_WAIT
 
    @@: lea	esi, [ebx + SOCKET.RCV_NXT]
    call    inc_inet_esi
 
    ; Send an ACK
    mov     eax, EMPTY_QUEUE
    call    dequeue
    cmp     ax, NO_BUFFER
	je	.exit
 
    push    eax
 
	mov	bl, TH_ACK
	xor	ecx, ecx
	xor	esi, esi
	stdcall build_tcp_packet, [sockAddr]
 
    mov     eax, NET1OUT_QUEUE
 
    mov     edx, [stack_ip]
	mov	ecx, [sockAddr]
	cmp	edx, [ecx + SOCKET.RemoteIP]
	jne	.not_local
    mov     eax, IPIN_QUEUE
 
  .not_local:
    ; Send it.
    pop     ebx
    call    queue
 
  .exit:
    ret
endp
 
 
proc stateTCB_FIN_WAIT_2 stdcall, sockAddr:DWORD
	test	[edx + 20 + TCP_PACKET.Flags], TH_FIN
	jz	.exit
 
    ; Change state, as we have a fin
	mov	[ebx + SOCKET.TCBState], TCB_TIMED_WAIT
 
	lea	esi, [ebx + SOCKET.RCV_NXT]
	call	inc_inet_esi
 
    ; Send an ACK
    mov     eax, EMPTY_QUEUE
    call    dequeue
    cmp     ax, NO_BUFFER
	je	.exit
 
    push    eax
 
	mov	bl, TH_ACK
	xor	ecx, ecx
	xor	esi, esi
	stdcall build_tcp_packet, [sockAddr]
 
    mov     eax, NET1OUT_QUEUE
 
    mov     edx, [stack_ip]
	mov	ecx, [sockAddr]
	cmp	edx, [ecx + SOCKET.RemoteIP]
	jne	.not_local
    mov     eax, IPIN_QUEUE
 
  .not_local:
       ; Send it.
    pop     ebx
    call    queue
 
  .exit:
    ret
endp
 
 
proc stateTCB_CLOSE_WAIT stdcall, sockAddr:DWORD
    ; Intentionally left empty
    ; socket_close_tcp handles this
    ret
endp
 
 
proc stateTCB_CLOSING stdcall, sockAddr:DWORD
    ; We can either receive an ACK of a fin, or a fin
	test	[edx + 20 + TCP_PACKET.Flags], TH_ACK
	jz	.exit
 
	mov	[ebx + SOCKET.TCBState], TCB_TIMED_WAIT
 
  .exit:
    ret
endp
 
 
proc stateTCB_LAST_ACK stdcall, sockAddr:DWORD
    ; Look at control flags - expecting an ACK
	test	[edx + 20 + TCP_PACKET.Flags], TH_ACK
	jz	.exit
 
    ; delete the socket
	stdcall net_socket_free, ebx
 
 
 
 
 
 
  .exit:
    ret
endp
 
 
proc stateTCB_TIME_WAIT stdcall, sockAddr:DWORD
    ret
endp
 
 
proc stateTCB_CLOSED stdcall, sockAddr:DWORD
    ret
endp

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

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibri_pe/network/tcp.inc – Rev 914 → 2971