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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/network/tcp.inc @ 1629 – Rev 1183 → 1288