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

 ;;                                                              ;;
 ;;  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: 871 $
+$Revision: 907 $
-TCB_FIN_WAIT_1     equ        5
+TCB_FIN_WAIT_1	   equ	      5
-TCB_FIN_WAIT_2     equ        6
+TCB_FIN_WAIT_2	   equ	      6
-TCB_CLOSE_WAIT     equ        7
+TCB_CLOSE_WAIT	   equ	      7
-TCB_CLOSING        equ        8
+TCB_CLOSING	   equ	      8
-TCB_LAST_ACK       equ        9
+TCB_LAST_ACK	   equ	      9
-TCB_TIME_WAIT      equ        10
+TCB_TIMED_WAIT	   equ	      10
-TCB_CLOSED         equ        11
+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
+TWOMSL		    equ     10	    ; # of secs to wait before closing socket
 ;   Description
 ;       Handles sockets in the timewait state, closing them
 ;       when the TCB timer expires
+;
 ;***************************************************************************
-tcp_tcb_handler:
-    ; scan through all the sockets, decrementing active timers
-    mov     eax, SOCKETBUFFSIZE * NUM_SOCKETS
+proc tcp_tcb_handler stdcall uses ebx
-    mov     ecx, NUM_SOCKETS
-tth1:
-    sub     eax, SOCKETBUFFSIZE
-    cmp     [eax + sockets + 32], dword 0
-    jne     tth2
-tth1a:
+	; scan through all the sockets, decrementing active timers
+	mov	ebx, net_sockets
+	cmp	[ebx + SOCKET.NextPtr], 0
-    cmp     [eax + sockets + 72], dword 0
+	je	.exit
+	DEBUGF	1, "K : sockets:\n"
-    jne     tth4
+  .next_socket:
+	mov	ebx, [ebx + SOCKET.NextPtr]
+	or	ebx, ebx
+	jz	.exit
+	DEBUGF	1, "K :   %x: %x-%x-%x-%u\n", ebx, [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
-    loop    tth1
+	jne	.decrement_wnd
-    ret
+	jmp	.next_socket
-tth2:
-    ; decrement it, delete socket if TCB timer = 0 & socket in timewait state
-    pusha
-    dec     dword [eax + sockets + 32]
-    cmp     [eax + sockets + 32], dword 0
-    jne     tth3
-    cmp     [eax + sockets + 28], dword TCB_TIME_WAIT
-    jne     tth3
-    ; OK, delete socket
-    mov     edi, eax
-    add     edi, sockets
-    xor     eax, eax
+  .decrement_tcb:
-    mov     ecx, SOCKETHEADERSIZE
+	; decrement it, delete socket if TCB timer = 0 & socket in timewait state
-    cld
+	dec	[ebx + SOCKET.TCBTimer]
-    rep     stosb
+	jnz	.next_socket
-tth3:
+	cmp	[ebx + SOCKET.TCBState], TCB_TIMED_WAIT
+	jne	.next_socket
     popa
-    jmp     tth1a
+	push	[ebx + SOCKET.PrevPtr]
+	stdcall net_socket_free, ebx
-    loop    tth1
-    ret
-    ; TODO - prove it works!
-tth4:
+	pop	ebx
-    dec     dword [eax + sockets + 72]
+	jmp	.next_socket
-    loop    tth1
+  .decrement_wnd:
-    ret
+	; TODO - prove it works!
 	dec	[ebx + SOCKET.wndsizeTimer]
 ;   Description
 ;       Handles queued TCP data
 ;       This is a kernel function, called by stack_handler
+;
 ;***************************************************************************
-tcp_tx_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	esi, resendQ
-    mov     ecx, 0
+	mov	ecx, 0
-tth001:
+  .next_resendq:
+	cmp	ecx, NUMRESENDENTRIES
-    cmp     ecx, NUMRESENDENTRIES
+	je	.exit		    ; None left
-    je      tth003              ; None left
+	;cmp     [esi], byte 0xFF                                    ; XTODO: 0xff -> 0
-    cmp     [esi], byte 0xFF
+	cmp	dword[esi + 4], 0
-    jne     tth002              ; found one
+	jne	@f		     ; found one
-    inc     ecx
+	inc	ecx
-    add     esi, 4
-    jmp     tth001
+	add	esi, 8
 	jmp	.next_resendq
-tth002:
-    ; we have one. decrement it's timer by 1
-    dec     word [esi+2]
-    mov     ax, [esi+2]
+    @@: ; we have one. decrement it's timer by 1
-    cmp     ax, 0
+	dec	word[esi + 2]
-    je      tth002a
+	jz	@f
-    inc     ecx
+	inc	ecx
+	add	esi, 8
-    add     esi, 4
+	jmp	.next_resendq	    ; Timer not zero, so move on
     jmp     tth001              ; Timer not zero, so move on
     @@:
-tth002a:
+	;mov     bl, 0xff                                             ; XTODO: bl -> ebx, 0xff -> 0
-    mov     bl, 0xff
+	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
+	; restart timer, and decrement retries
-    dec     byte [esi+1]
+	; After the first resend, back of on next, by a factor of 5
+	mov	[esi + 2], word TCP_TIMEOUT * 5
-    mov     al, [esi+1]
+	dec	byte[esi + 1]
-    cmp     al, 0
-    jne     tth004
+	jnz	@f
-    ; retries now 0, so delete from queue
+	; retries now 0, so delete from queue
-    xchg     [esi], bl
+	;xchg     [esi], bl                                          ; XTODO: bl -> ebx
-tth004:
+	xchg	 [esi + 4], ebx
-    ; resend packet
+    @@: ; resend packet
+	pushad
-    pusha
+	mov	eax, EMPTY_QUEUE
+	call	dequeue
-    mov     eax, EMPTY_QUEUE
+	cmp	ax, NO_BUFFER
-    call    dequeue
+	jne	.tth004z
-    cmp     ax, NO_BUFFER
-    jne      tth004z
+	; TODO - try again in 10ms.
-    ; TODO - try again in 10ms.
+	;cmp     bl, 0xff                                            ; XTODO: 0xff -> 0
-    cmp     bl, 0xff
+	test	ebx, ebx
-    jne     tth004za
+	jnz	@f
-    mov     [esi], bl
+	;mov     [esi], bl                                            ; XTODO: bl -> ebx
-tth004za:
-    ; Mark it to expire in 10ms - 1 tick
+	mov	[esi + 4], ebx
     mov     [esi+1], byte 1
-    mov     [esi+2], word 1
+    @@: ; Mark it to expire in 10ms - 1 tick
-    jmp     tth005
+	mov	byte[esi + 1], 1
 	mov	word[esi + 2], 1
-tth004z:
+	jmp	.tth005
     ; we have a buffer # in ax
-    push    eax
-    push    ecx
+  .tth004z:
-    mov     ecx, IPBUFFSIZE
+	; we have a buffer # in ax
-    mul     ecx
-    add     eax, IPbuffs
+	push	eax ecx
+	mov	ecx, IPBUFFSIZE
-    ; we have the buffer address in eax
+	mul	ecx
-    mov     edi, eax
+	add	eax, IPbuffs
     pop     ecx
+	; we have the buffer address in eax
-    ; get resend data address
+	mov	edi, eax
-    inc     ecx
+	pop	ecx
+	; Now get buffer location, and copy buffer across. argh! more copying,,
-    ; Now get buffer location, and copy buffer across. argh! more copying,,
+	mov	esi, resendBuffer
-    mov     esi, resendBuffer - IPBUFFSIZE
-tth004a:
-    add     esi, IPBUFFSIZE
-    loop    tth004a
+    @@: add	esi, IPBUFFSIZE
-    ; we have resend buffer location in esi
+	loop	@b
-    mov     ecx, IPBUFFSIZE
-    ; copy data across
+	; we have resend buffer location in esi
-    cld
+	mov	ecx, IPBUFFSIZE
-    rep     movsb
 	; copy data across
-    ; queue packet
 	push	edi
+	cld
-    mov     eax, NET1OUT_QUEUE
+	rep	movsb
 	pop	edi
-    mov     edx, [stack_ip]
-    mov     ecx, [ edi + 16 ]
+	; queue packet
-    cmp     edx, ecx
+	mov	eax, NET1OUT_QUEUE
-    jne     tth004b
+	mov	edx, [stack_ip]
-    mov     eax, IPIN_QUEUE
+	cmp	edx, [edi + IP_PACKET.DestinationAddress]
-tth004b:
+	jne	.not_local
-    pop     ebx
+	mov	eax, IPIN_QUEUE
 ;       IP buffer address given in edx
 ;          IP buffer number in eax
 ;          Free up (or re-use) IP buffer when finished
+;
 ;***************************************************************************
-tcp_rx:
+proc tcp_rx stdcall uses ebx
-    ; The process is as follows.
+	; The process is as follows.
-    ; Look for a socket with matching remote IP, remote port, local port
+	; Look for a socket with matching remote IP, remote port, local port
-    ; if not found, then
+	; if not found, then
-    ; look for remote IP + local port match ( where sockets remote port = 0)
+	; look for remote IP + local port match ( where sockets remote port = 0)
-    ; if not found, then
+	; if not found, then
-    ; Look for a socket where
+	; Look for a socket where
-    ; IP Packet TCP Destination Port = local Port
+	; IP Packet TCP Destination Port = local Port
-    ; IP Packet SA = Remote IP
+	; IP Packet SA = Remote IP
-    ; IP Packet TCP Source Port = remote Port
+	; IP Packet TCP Source Port = remote Port
+	mov	ebx, net_sockets
+  .next_socket.1:
+	mov	ebx, [ebx + SOCKET.NextPtr]
-    mov     eax, SOCKETBUFFSIZE * NUM_SOCKETS
+	or	ebx, ebx
-    mov     ecx, NUM_SOCKETS
+	jz	.next_socket.1.exit
-ss1:
+	cmp	[ebx + SOCKET.Status], SOCK_OPEN
+	jne	.next_socket.1
+;        DEBUGF  1, "K : tcp_rx - 1.dport: %x - %x\n", [edx + 20 + TCP_PACKET.DestinationPort]:4, [ebx + SOCKET.LocalPort]:4
-    sub     eax, SOCKETBUFFSIZE
-    movzx   ebx, word [edx + 22]     ; get the dest. port from the TCP hdr
+	mov	ax, [edx + 20 + TCP_PACKET.DestinationPort]  ; get the dest. port from the TCP hdr
-    cmp     [eax + sockets + 12], bx ; compare with socket's local port
+	cmp	[ebx + SOCKET.LocalPort], ax		; get the dest. port from the TCP hdr
+	jne	.next_socket.1				; different - try next socket
-    jnz     nxttst1                        ; different - try next socket
+;        DEBUGF  1, "K : tcp_rx - 1.addr: %x - %x\n", [edx + IP_PACKET.SourceAddress], [ebx + SOCKET.RemoteIP]
-    movzx   ebx, word [edx + 20]       ; get the source port from the TCP hdr
+	mov	eax, [edx + IP_PACKET.SourceAddress]	; get the source IP Addr from the IP hdr
-    cmp     [eax + sockets + 20], bx ; compare with socket's remote port
+	cmp	[ebx + SOCKET.RemoteIP], eax		; compare with socket's remote IP
-    jnz     nxttst1                        ; different - try next socket
+	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     ebx, [edx + 12]           ; get the source IP Addr from the IP hdr
+	mov	ax, [edx + 20 + TCP_PACKET.SourcePort]	; get the source port from the TCP hdr
-    cmp     [eax + sockets + 16], ebx ; compare with socket's remote IP
+	cmp	[ebx + SOCKET.RemotePort], ax		; compare with socket's remote port
-    jnz     nxttst1                        ; different - try next socket
+	jne	.next_socket.1				; different - try next socket
-    ; We have a complete match - use this socket
+	; We have a complete match - use this socket
-    jmp     tcprx_001
 	jmp	.change_state
 nxttst1:
-    loop    ss1                     ; Return back if no match
+  .next_socket.1.exit:
-    ; If we got here, there was no match
+	; If we got here, there was no match
+	; Look for a socket where
+	; IP Packet TCP Destination Port = local Port
+	; IP Packet SA = Remote IP
-    ; Look for a socket where
+	; socket remote Port = 0
+	mov	ebx, net_sockets
-    ; IP Packet TCP Destination Port = local Port
+  .next_socket.2:
+	mov	ebx, [ebx + SOCKET.NextPtr]
+	or	ebx, ebx
+	jz	.next_socket.2.exit
+	cmp	[ebx + SOCKET.Status], SOCK_OPEN
+	jne	.next_socket.2
-    ; IP Packet SA = Remote IP
-    ; socket remote Port = 0
+;        DEBUGF  1, "K : tcp_rx - 2.dport: %x - %x\n", [edx + 20 + TCP_PACKET.DestinationPort]:4, [ebx + SOCKET.LocalPort]:4
-    mov     eax, SOCKETBUFFSIZE * NUM_SOCKETS
+	mov	ax, [edx + 20 + TCP_PACKET.DestinationPort]  ; get the dest. port from the TCP hdr
-    mov     ecx, NUM_SOCKETS
+	cmp	[ebx + SOCKET.LocalPort], ax		; compare with socket's local port
+	jne	.next_socket.2				; different - try next socket
-ss2:
-    sub     eax, SOCKETBUFFSIZE
-    movzx   ebx, word [edx + 22]     ; get the dest. port from the TCP hdr
+;        DEBUGF  1, "K : tcp_rx - 2.addr: %x - %x\n", [edx + IP_PACKET.SourceAddress], [ebx + SOCKET.RemoteIP]
-    cmp     [eax + sockets + 12], bx ; compare with socket's local port
-    jnz     nxttst2                        ; different - try next socket
+	mov	eax, [edx + IP_PACKET.SourceAddress]	; get the source IP Addr from the IP hdr
-    mov     ebx, [edx + 12]          ; get the source IP Addr from the IP hdr
+	cmp	[ebx + SOCKET.RemoteIP], eax		; compare with socket's remote IP
-    cmp     [eax + sockets + 16], ebx ; compare with socket's remote IP
+	jne	.next_socket.2				; different - try next socket
-    jnz     nxttst2                        ; different - try next socket
-    mov     ebx, 0
+;        DEBUGF  1, "K : tcp_rx - 2.sport: 0000 - %x\n", [ebx + SOCKET.RemotePort]:4
     cmp     [eax + sockets + 20], bx ; only match a remote socket of 0
-    jnz     nxttst2                        ; different - try next socket
+	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
+	; We have a complete match - use this socket
+	jmp	.change_state
-    jmp     tcprx_001
+  .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
-nxttst2:
+	mov	ebx, net_sockets
-    loop    ss2                     ; Return back if no match
+  .next_socket.3:
+	mov	ebx, [ebx + SOCKET.NextPtr]
+	or	ebx, ebx
-    ; If we got here, there was no match
+	jz	.next_socket.3.exit
-    ; Look for a socket where
-    ; IP Packet TCP Destination Port = local Port
+	cmp	[ebx + SOCKET.Status], SOCK_OPEN
-    ; socket Remote IP = 0
-    ; socket remote Port = 0
+	jne	.next_socket.3
-    mov     eax, SOCKETBUFFSIZE * NUM_SOCKETS
-    mov     ecx, NUM_SOCKETS
+;        DEBUGF  1, "K : tcp_rx - 3.dport: %x - %x\n", [edx + 20 + TCP_PACKET.DestinationPort]:4, [ebx + SOCKET.LocalPort]:4
-ss3:
-    sub     eax, SOCKETBUFFSIZE
+	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
-    movzx   ebx, word [edx + 22]     ; get destination port from the TCP hdr
+	jne	.next_socket.3				; different - try next socket
-    cmp     [eax + sockets + 12], bx ; compare with socket's local port
     jnz     nxttst3                        ; different - try next socket
-    mov     ebx, 0
+;        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
-    cmp     [eax + sockets + 20], bx ; only match a remote socket of 0
+  .next_socket.3.exit:
+	; If we got here, we need to reject the packet
-    jnz     nxttst3                        ; different - try next socket
+	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
-    mov     ebx, 0
+;       mov     ebx, net_sockets
     cmp     [eax + sockets + 16], ebx ; only match a socket remote IP of 0
-    jnz     nxttst3                        ; different - try next socket
+; .next_socket.4:
+;       mov     ebx, [ebx + SOCKET.NextPtr]
+;       or      ebx, ebx
-    ; We have a complete match - use this socket
+;       jz      .next_socket.4.exit
-    jmp     tcprx_001
+;       DEBUGF  1, "K :   %x: %x-%x-%x-%u\n", ebx, [ebx + SOCKET.LocalPort]:4, [ebx + SOCKET.RemoteIP], [ebx + SOCKET.RemotePort]:4, [ebx + SOCKET.TCBState]
-nxttst3:
+;       jne     .next_socket.4
-    loop    ss3                     ; Return back if no match
+;
 ; .next_socket.4.exit:
-    ; If we got here, we need to reject the packet
+	inc	[dumped_rx_count]
-    inc     dword [dumped_rx_count]
+	jmp	.exit
 ;          User data pointed to by esi
 ;       Data length in ecx
 ;          Transmit buffer number in eax
+;
 ;***************************************************************************
-buildTCPPacket:
+proc build_tcp_packet stdcall, sockAddr:DWORD
-    push    ecx                        ; Save data length
+	push	ecx			   ; Save data length
-    ; convert buffer pointer eax to the absolute address
+	; convert buffer pointer eax to the absolute address
-    mov     ecx, IPBUFFSIZE
+	mov	ecx, IPBUFFSIZE
-    mul     ecx
+	mul	ecx
-    add     eax, IPbuffs
+	add	eax, IPbuffs
-    mov     edx, eax
+	mov	edx, eax
-    mov     [edx + 33], bl            ; TCP flags
+	mov	[edx + 20 + TCP_PACKET.Flags], bl		; TCP flags
-    mov     ebx, [sktAddr]
+	mov	ebx, [sockAddr]
-    ; So, ebx holds the socket ptr, edx holds the IPbuffer ptr
+	; So, ebx holds the socket ptr, edx holds the IPbuffer ptr
-    ; Fill in the IP header ( some data is in the socket descriptor)
-    mov     eax, [ebx + 8]
+	; Fill in the IP header ( some data is in the socket descriptor)
-    mov     [edx + 12], eax      ; source IP
-    mov     eax, [ebx + 16]
+	mov	eax, [ebx + SOCKET.LocalIP]
-    mov     [edx + 16], eax      ; Destination IP
+	mov	[edx + IP_PACKET.SourceAddress], eax
 	mov	eax, [ebx + SOCKET.RemoteIP]
-    mov     al, 0x45
+	mov	[edx + IP_PACKET.DestinationAddress], eax
-    mov     [edx], al         ; Version, IHL
-    xor     al, al
-    mov     [edx + 1], al     ; Type of service
+	mov	[edx + IP_PACKET.VersionAndIHL], 0x45
-    pop     eax                   ; Get the TCP data length
+	mov	[edx + IP_PACKET.TypeOfService], 0
-    push    eax
-    add     eax, 20 + 20           ; add IP header and TCP header lengths
-    mov     [edx + 2], ah
-    mov     [edx + 3], al
-    xor     al, al
+	pop	eax		      ; Get the TCP data length
-    mov     [edx + 4], al
+	push	eax
-    mov     [edx + 5], al
     mov     al, 0x40
-    mov     [edx + 6], al
-    xor     al, al
+	add	eax, 20 + 20	       ; add IP header and TCP header lengths
-    mov     [edx + 7], al
+	rol	ax, 8
-    mov     al, 0x20
+	mov	[edx + IP_PACKET.TotalLength], ax
-    mov     [edx + 8], al
+	mov	[edx + IP_PACKET.Identification], 0
-    mov     al, 6                         ; TCP protocol
+	mov	[edx + IP_PACKET.FlagsAndFragmentOffset], 0x0040
-    mov     [edx + 9], al
+	mov	[edx + IP_PACKET.TimeToLive], 0x20
 	mov	[edx + IP_PACKET.Protocol], PROTOCOL_TCP
-    ; Checksum left unfilled
-    xor     ax, ax
-    mov     [edx + 10], ax
+	; Checksum left unfilled
+	mov	[edx + IP_PACKET.HeaderChecksum], 0
-    ; Fill in the TCP header ( some data is in the socket descriptor)
-    mov     ax, [ebx + 12]
+	; Fill in the TCP header (some data is in the socket descriptor)
-    mov     [edx + 20], ax        ; Local Port
+	mov	ax, [ebx + SOCKET.LocalPort]
+	mov	[edx + 20 + TCP_PACKET.SourcePort], ax		; Local Port
     mov     ax, [ebx + 20]
-    mov     [edx + 20 + 2], ax    ; desitination Port
+	mov	ax, [ebx + SOCKET.RemotePort]
-    ; Checksum left unfilled
+	mov	[edx + 20 + TCP_PACKET.DestinationPort], ax	; desitination Port
     xor     ax, ax
-    mov     [edx + 20 + 16], ax
+	; Checksum left unfilled
-    ; sequence number
+	mov	[edx + 20 + TCP_PACKET.Checksum], 0
-    mov     eax, [ebx + 48]
-    mov     [edx + 20 + 4], eax
 	; sequence number
-    ; ack number
+	mov	eax, [ebx + SOCKET.SND_NXT]
-    mov     eax, [ebx + 56]
+	mov	[edx + 20 + TCP_PACKET.SequenceNumber], eax
-    mov     [edx + 20 + 8], eax
 	; ack number
-    ; window ( 0x2000 is default ).I could accept 4KB, fa0, ( skt buffer size)
+	mov	eax, [ebx + SOCKET.RCV_NXT]
-    ; 768 bytes seems better
+	mov	[edx + 20 + TCP_PACKET.AckNumber], eax
     mov     ax, 0x0003
-    mov     [edx + 20 + 14], ax
+	; window ( 0x2000 is default ).I could accept 4KB, fa0, ( skt buffer size)
-    ; Urgent pointer (0)
+	; 768 bytes seems better
-    mov     ax, 0
+	mov	[edx + 20 + TCP_PACKET.Window], 0x0003
-    mov     [edx + 20 + 18], ax
 	; Urgent pointer (0)
-    ; data offset ( 0x50 )
+	mov	[edx + 20 + TCP_PACKET.UrgentPointer], 0
     mov     al, 0x50
-    mov     [edx + 20 + 12], al
+	; data offset ( 0x50 )
-    pop     ecx                  ; count of bytes to send
+	mov	[edx + 20 + TCP_PACKET.DataOffset], 0x50
-    mov     ebx, ecx            ; need the length later
-    cmp     ebx, 0
+	pop	ecx		     ; count of bytes to send
-    jz      btp_001
+	mov	ebx, ecx	    ; need the length later
-    mov     edi, edx
+	cmp	ebx, 0
-    add     edi, 40
+	jz	@f
     cld
-    rep     movsb               ; copy the data across
+	mov	edi, edx
 	add	edi, 40
-btp_001:
+	cld
-    ; we have edx as IPbuffer ptr.
+	rep	movsb		    ; copy the data across
     ; Fill in the TCP checksum
-    ; First, fill in pseudoheader
+    @@: ; we have edx as IPbuffer ptr.
-    mov     eax, [edx + 12]
-    mov     [pseudoHeader], eax
+	; Fill in the TCP checksum
-    mov     eax, [edx + 16]
+	; First, fill in pseudoheader
-    mov     [pseudoHeader+4], eax
+	mov	eax, [edx + IP_PACKET.SourceAddress]
-    mov     ax, 0x0600            ; 0 + protocol
+	mov	[pseudoHeader], eax
-    mov     [pseudoHeader+8], ax
+	mov	eax, [edx + IP_PACKET.DestinationAddress]
-    add     ebx, 20
-    mov     eax, ebx
+	mov	[pseudoHeader + 4], eax
-    mov     [pseudoHeader+10], ah
+	mov	word[pseudoHeader + 8], PROTOCOL_TCP shl 8 + 0
-    mov     [pseudoHeader+11], al
+	add	ebx, 20
+	mov	[pseudoHeader + 10], bh
 	mov	[pseudoHeader + 11], bl
-    mov     eax, pseudoHeader
-    mov     [checkAdd1], eax
+	mov	eax, pseudoHeader
-    mov     [checkSize1], word 12
-    mov     eax, edx
+	mov	[checkAdd1], eax
-    add     eax, 20
+	mov	word[checkSize1], 12
-    mov     [checkAdd2], eax
-    mov     eax, ebx
-    mov     [checkSize2], ax
-    call    checksum
+	mov	eax, edx
-    ; store it in the TCP checksum ( in the correct order! )
-    mov     ax, [checkResult]
-    mov     [edx + 20 + 16], ah
-    mov     [edx + 20 + 17], al
-    ; Fill in the IP header checksum
-    GET_IHL eax,edx              ; get IP-Header length
-    stdcall checksum_jb,edx,eax  ; buf_ptr, buf_size
-    mov     [edx + 10], ah
-    mov     [edx + 11], al
+	add	eax, 20
+	mov	[checkAdd2], eax
-    ret
 	mov	eax, ebx
-; Increments the 32 bit value pointed to by esi in internet order
+	mov	[checkSize2], ax
-inc_inet_esi:
+	call	checksum
     push    eax
-    add     esi, 3
+	; store it in the TCP checksum ( in the correct order! )
-    mov     al, byte[esi]
+	mov	ax, [checkResult]
-    inc     al
-    mov     byte[esi], al
+	rol	ax, 8
-    cmp     al, 0
+	mov	[edx + 20 + TCP_PACKET.Checksum], ax
-    jnz     iie_exit
-    dec     esi
-    mov     al, byte[esi]
-    inc     al
-    mov     byte[esi], al
-    cmp     al, 0
-    jnz     iie_exit
-    dec     esi
     mov     al, byte[esi]
-    inc     al
-    mov     byte[esi], al
-    cmp     al, 0
-    jnz     iie_exit
-    dec     esi
-    mov     al, byte[esi]
+	; Fill in the IP header checksum
-    inc     al
-    mov     byte[esi], al
-iie_exit:
+	GET_IHL eax, edx	       ; get IP-Header length
-    pop     eax
+	stdcall checksum_jb, edx, eax  ; buf_ptr, buf_size
-    ret
+	rol	ax, 8
+	mov	[edx + IP_PACKET.HeaderChecksum], ax
+	ret
-; Increments the 32 bit value pointed to by esi in internet order
+endp
-; by the value in ecx
-add_inet_esi:
-    push    eax
+; Increments the 32 bit value pointed to by esi in internet order
+proc inc_inet_esi stdcall
-    mov     al, [esi]
+	push	eax
-    shl     eax, 8
+	mov	eax, [esi]
-    inc     esi
+	bswap	eax
-    mov     al, [esi]
+	inc	eax
-    shl     eax, 8
+	bswap	eax
-    inc     esi
+	mov	[esi], eax
-    mov     al, [esi]
+	pop	eax
+	ret
-    shl     eax, 8
+endp
     inc     esi
     mov     al, [esi]
-    add     eax, ecx
+; Increments the 32 bit value pointed to by esi in internet order
-    mov     [esi], al
+; by the value in ecx
-    dec     esi
+proc add_inet_esi stdcall
-    shr     eax, 8
+	push	eax
-    mov     [esi], al
+	mov	eax, [esi]
-    dec     esi
+	bswap	eax
-    shr     eax, 8
+	add	eax, ecx
-    mov     [esi], al
+	bswap	eax
-    dec     esi
+	mov	[esi], eax
-    shr     eax, 8
+	pop	eax
-    mov     [esi], al
-    pop     eax
-    ret
+	ret
 endp
-iglobal
-  TCBStateHandler:
     dd      stateTCB_LISTEN
-    dd      stateTCB_SYN_SENT
+iglobal
-    dd      stateTCB_SYN_RECEIVED
+  TCBStateHandler dd \
-    dd      stateTCB_ESTABLISHED
+    stateTCB_LISTEN, \
-    dd      stateTCB_FIN_WAIT_1
+    stateTCB_SYN_SENT, \
-    dd      stateTCB_FIN_WAIT_2
-    dd      stateTCB_CLOSE_WAIT
-    dd      stateTCB_CLOSING
+    stateTCB_SYN_RECEIVED, \
-    dd      stateTCB_LAST_ACK
-    dd      stateTCB_TIME_WAIT
+    stateTCB_ESTABLISHED, \
-    dd      stateTCB_CLOSED
+    stateTCB_FIN_WAIT_1, \
-endg
+    stateTCB_FIN_WAIT_2, \
+    stateTCB_CLOSE_WAIT, \
-;***************************************************************************
+    stateTCB_CLOSING, \
-;   Function
+    stateTCB_LAST_ACK, \
-;      tcpStateMachine
+    stateTCB_TIME_WAIT, \
     stateTCB_CLOSED
-;   Description
+endg
-;       TCP state machine
-;       This is a kernel function, called by tcp_rx
+;***************************************************************************
 ;   Function
-;       IP buffer address given in edx
+;      tcpStateMachine
-;          Socket/TCB address in [eax + sockets]
+;
-;
+;   Description
-;       The IP buffer will be released by the caller
+;       TCP state machine
-;***************************************************************************
+;       This is a kernel function, called by tcp_rx
 tcpStateMachine:
-    mov     ebx, sockets
-    add     ebx, eax
+;       IP buffer address given in edx
-    mov     [sktAddr], ebx
-    ; as a packet has been received, update the TCB timer
+;          Socket/TCB address in ebx
-    mov     ecx, TWOMSL
+;
-    mov     [ebx + 32], ecx
+;       The IP buffer will be released by the caller
 ;***************************************************************************
     ; If the received packet has an ACK bit set,
-    ; remove any packets in the resend queue that this
-    ; received packet acknowledges
+proc tcpStateMachine stdcall, sockAddr:DWORD
-    pusha
+	; as a packet has been received, update the TCB timer
-    mov     cl, [edx + 33]
-    and     cl, 0x10
-    cmp     cl, 0x10
-    jne     tsm001                      ; No ACK, so no data yet
+	mov	[ebx + SOCKET.TCBTimer], TWOMSL
-    ; get skt number in al
-    shr     eax, 12
+	; If the received packet has an ACK bit set,
 	; remove any packets in the resend queue that this
-    ; The ack number is in [edx + 28], inet format
+	; received packet acknowledges
-    ; skt in al
-    mov     esi, resendQ
+	pushad
-    mov     ecx, 0
+	test	[edx + 20 + TCP_PACKET.Flags], TH_ACK
-t001:
-    cmp     ecx, NUMRESENDENTRIES
-    je      t003              ; None left
+	jz	.call_handler					; No ACK, so no data yet
     cmp     [esi], al
-    je      t002              ; found one
+	; get skt number in eax
-    inc     ecx
+	stdcall net_socket_addr_to_num, ebx
-    add     esi, 4
-    jmp     t001
+	; The ack number is in [edx + 28], inet format
+	; skt in eax
-t002:                   ; Can we delete this buffer?
-                        ; If yes, goto t004. No, goto t001
-    ; Get packet data address
+	mov	esi, resendQ
-    push    ecx
+	xor	ecx, ecx
     inc     ecx
-    ; Now get buffer location, and copy buffer across. argh! more copying,,
+  .next_resendq:
-    mov     edi, resendBuffer - IPBUFFSIZE
+	cmp	ecx, NUMRESENDENTRIES
-t002a:
-    add     edi, IPBUFFSIZE
-    loop    t002a
+	je	.call_handler	  ; None left
+	;cmp     [esi], al                                       ; XTODO: al -> eax
-    ; we have dest buffer location in edi. incoming packet in edx.
+	cmp	[esi + 4], eax
-    ; Get this packets sequence number
-    ; preserve al, ecx, esi, edx
-    mov     cl, [edi + 24]
-    shl     ecx, 8
+	je	@f		  ; found one
-    mov     cl, [edi + 25]
+	inc	ecx
+	add	esi, 8
-    shl     ecx, 8
+	jmp	.next_resendq
-    mov     cl, [edi + 26]
+    @@: 		  ; Can we delete this buffer?
-    shl     ecx, 8
+			  ; If yes, goto @@. No, goto .next_resendq
+	; Get packet data address
-    mov     cl, [edi + 27]
-    movzx   ebx, byte [edi + 3]
+	push	ecx
-    mov     bh, [edi + 2]
+	; Now get buffer location, and copy buffer across. argh! more copying,,
-    sub     ebx, 40
+	imul	edi, ecx, IPBUFFSIZE
-    add     ecx, ebx          ; ecx is now seq# of last byte +1, intel format
+	add	edi, resendBuffer
-    ; get recievd ack #, in intel format
-    mov     bl, [edx + 28]
-    shl     ebx, 8
+	; we have dest buffer location in edi. incoming packet in edx.
-    mov     bl, [edx + 29]
+	; Get this packets sequence number
-    shl     ebx, 8
+	; preserve al, ecx, esi, edx
-    mov     bl, [edx + 30]
+	mov	ecx, [edi + 20 + TCP_PACKET.SequenceNumber]
-    shl     ebx, 8
+	bswap	ecx
-    mov     bl, [edx + 31]
+	movzx	ebx, word[edi + 2]
+	xchg	bl, bh
-    cmp     ebx, ecx        ; Finally. ecx = rx'ed ack. ebx = last byte in que
+	sub	ebx, 40
-                            ; DANGER! need to handle case that we have just
+	add	ecx, ebx	  ; ecx is now seq# of last byte +1, intel format
-                            ; passed the 2**32, and wrapped round!
-    pop     ecx
+	; get recievd ack #, in intel format
-    jae     t004             ; if rx > old, delete old
-    inc     ecx
+	mov	ebx, [edx + 20 + TCP_PACKET.AckNumber]
-    add     esi, 4
+	bswap	ebx
-    jmp     t001
 	cmp	ebx, ecx	; Finally. ecx = rx'ed ack. ebx = last byte in que
 				; DANGER! need to handle case that we have just
-t004:
+				; passed the 2**32, and wrapped round!
-    dec     dword [arp_rx_count] ; ************ TEST ONLY!
+	pop	ecx
+	jae	@f		; if rx > old, delete old
     mov     [esi], byte 0xFF
-    inc     ecx
+	inc	ecx
-    add     esi, 4
+	add	esi, 8
-    jmp     t001
+	jmp	.next_resendq
-t003:
     ;@@: mov     byte[esi], 0xff                                 ; XTODO: 0xff -> 0
-tsm001:
+    @@: mov	dword[esi + 4], 0
-    popa
+	inc	ecx
+	add	esi, 8
-    ; Call handler for given TCB state
-    mov     ebx, [eax + sockets+28]
+	jmp	.next_resendq
     cmp     ebx, TCB_LISTEN
-    jb      tsm_exit
+  .call_handler:
-    cmp     ebx, TCB_CLOSED
+	popad
     ja      tsm_exit
 	; Call handler for given TCB state
+	mov	eax, [ebx + SOCKET.TCBState]
-    dec     ebx
-    call    dword [TCBStateHandler+ebx*4]
-tsm_exit:
-    ret
+	cmp	eax, TCB_LISTEN
+	jb	.exit
 	cmp	eax, TCB_CLOSED
+	ja	.exit
 stateTCB_LISTEN:
+	stdcall [TCBStateHandler + (eax - 1) * 4], [sockAddr]
-    ; 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
+  .exit:
 	ret
-    ; Look at control flags
-    mov     bl, [edx + 33]
-    and     bl, 0x02
-    cmp     bl, 0x02
-    jnz     stl_exit
-    ; We have a SYN. update the socket with this IP packets details,
-    ; And send a response
+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, [edx + 12] ; IP source address
+	mov	[ebx + SOCKET.RemotePort], ax
-    mov     [eax + sockets + 16], ebx
+	mov	eax, [edx + 20 + TCP_PACKET.SequenceNumber]
-    mov     bx, [edx + 20] ; IP source port
+	mov	[ebx + SOCKET.IRS], eax
-    mov     [eax + sockets + 20], bx
-    mov     ebx, [edx + 24] ; IRS
+	mov	[ebx + SOCKET.RCV_NXT], eax
-    mov     [eax + sockets + 40], ebx
+	lea	esi, [ebx + SOCKET.RCV_NXT]
-    mov     [eax + sockets + 56], ebx
+	call	inc_inet_esi ; RCV.NXT
-    mov     esi, sockets
+	mov	eax, [ebx + SOCKET.ISS]
-    add     esi, eax
+	mov	[ebx + SOCKET.SND_NXT], eax
     add     esi, 56
-    call    inc_inet_esi ; RCV.NXT
+	; Now construct the response, and queue for sending by IP
+	mov	eax, EMPTY_QUEUE
-    mov     ebx, [eax + sockets + 36]    ; ISS
+	call	dequeue
-    mov     [eax + sockets + 48], ebx    ; SND.NXT
+	cmp	ax, NO_BUFFER
-    ; Now construct the response, and queue for sending by IP
+	je	.exit
-    mov     eax, EMPTY_QUEUE
-    call    dequeue
-    cmp     ax, NO_BUFFER
+	push	eax
-    je      stl_exit
+	mov	bl, TH_SYN + TH_ACK
-    push    eax
+	xor	ecx, ecx
-    mov     bl, 0x12        ; SYN + ACK
+	xor	esi, esi
-    mov     ecx, 0
+	stdcall build_tcp_packet, [sockAddr]
-    mov     esi, 0
-    call    buildTCPPacket
+	mov	eax, NET1OUT_QUEUE
+	mov	edx, [stack_ip]
-    mov     eax, NET1OUT_QUEUE
+	mov	ecx, [sockAddr]
-    mov     edx, [stack_ip]
+	cmp	edx, [ecx + SOCKET.RemoteIP]
-    mov     ecx, [ sktAddr ]
+	jne	.not_local
-    mov     ecx, [ ecx + 16 ]
+	mov	eax, IPIN_QUEUE
     cmp     edx, ecx
+  .not_local:
-    jne     stl_notlocal
-    mov     eax, IPIN_QUEUE
+	; Send it.
 	pop	ebx
-stl_notlocal:
+	call	queue
        ; Send it.
+	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
     pop     ebx
-    call    queue
-    mov     ebx, TCB_SYN_RECEIVED
+proc stateTCB_SYN_SENT stdcall, sockAddr:DWORD
-    mov     esi, [sktAddr]
-    mov     [esi + 28], ebx
-    ; increament SND.NXT in socket
-    add     esi, 48
+	; We are awaiting an ACK to our SYN, with a SYM
-    call    inc_inet_esi
+	; Look at control flags - expecting an ACK
+	mov	al, [edx + 20 + TCP_PACKET.Flags]
+	and	al, TH_SYN + TH_ACK
-stl_exit:
+	cmp	al, TH_SYN + TH_ACK
-    ret
+	je	.syn_ack
+	test	al, TH_SYN
+	jz	.exit
-stateTCB_SYN_SENT:
-    ; We are awaiting an ACK to our SYN, with a SYM
+	mov	[ebx + SOCKET.TCBState], TCB_SYN_RECEIVED
-    ; Look at control flags - expecting an ACK
+	push	TH_SYN + TH_ACK
-    mov     bl, [edx + 33]
+	jmp	.send
-    and     bl, 0x12
-    cmp     bl, 0x12
-    jnz     stss_exit
+  .syn_ack:
+	mov	[ebx + SOCKET.TCBState], TCB_ESTABLISHED
-    mov     ebx, TCB_ESTABLISHED
+	push	TH_ACK
     mov     esi, [sktAddr]
-    mov     [esi + 28], ebx
+  .send:
 	; Store the recv.nxt field
-    ; Store the recv.nxt field
+	mov	eax, [edx + 20 + TCP_PACKET.SequenceNumber]
-    mov     eax, [edx + 24]
+	; 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
-    ; Update our recv.nxt field
+	call	dequeue
-    mov     esi, [sktAddr]
+	cmp	ax, NO_BUFFER
+	pop	ebx
+	je	.exit
+	push	eax
+	xor	ecx, ecx
+	xor	esi, esi
-    add     esi, 56
+	stdcall build_tcp_packet, [sockAddr]
-    mov     [esi], eax
-    call    inc_inet_esi
+	mov	eax, NET1OUT_QUEUE
+	mov	edx, [stack_ip]
-    ; Send an ACK
-    ; Now construct the response, and queue for sending by IP
-    mov     eax, EMPTY_QUEUE
-    call    dequeue
-    cmp     ax, NO_BUFFER
-    je      stss_exit
-    push    eax
-    mov     bl, 0x10        ; ACK
-    mov     ecx, 0
-    mov     esi, 0
-    call    buildTCPPacket
-    mov     eax, NET1OUT_QUEUE
-    mov     edx, [stack_ip]
-    mov     ecx, [ sktAddr ]
-    mov     ecx, [ ecx + 16 ]
+	mov	ecx, [sockAddr]
-    cmp     edx, ecx
+	cmp	edx, [ecx + SOCKET.RemoteIP]
-    jne     stss_notlocal
-    mov     eax, IPIN_QUEUE
+	jne	.not_local
 	mov	eax, IPIN_QUEUE
 stss_notlocal:
-       ; Send it.
+  .not_local:
-    pop     ebx
+	; Send it.
-    call    queue
+	pop	ebx
-stss_exit:
-    ret
+	call	queue
   .exit:
-stateTCB_SYN_RECEIVED:
+	ret
-    ; In this case, we are expecting an ACK packet
-    ; For now, if the packet is an ACK, process it,
+endp
-    ; If not, ignore it
-    ; Look at control flags - expecting an ACK
+proc stateTCB_SYN_RECEIVED stdcall, sockAddr:DWORD
-    mov     bl, [edx + 33]
+	; In this case, we are expecting an ACK packet
-    and     bl, 0x10
-    cmp     bl, 0x10
-    jnz     stsr_exit
+	; For now, if the packet is an ACK, process it,
-    mov     ebx, TCB_ESTABLISHED
+	; If not, ignore it
     mov     esi, [sktAddr]
-    mov     [esi + 28], ebx
+	test	[edx + 20 + TCP_PACKET.Flags], TH_RST		;xxx
 	jz	.check_ack					;xxx
 stsr_exit:
-    ret
+	push	[ebx + SOCKET.OrigRemotePort] [ebx + SOCKET.OrigRemoteIP]
 	pop	[ebx + SOCKET.RemoteIP] [ebx + SOCKET.RemotePort]
+	mov	[ebx + SOCKET.TCBState], TCB_LISTEN		;xxx
-stateTCB_ESTABLISHED:
-    ; Here we are expecting data, or a request to close
-    ; OR both...
+	jmp	.exit						;xxx
-    ; Did we receive a FIN or RST?
-    mov     bl, [edx + 33]
+  .check_ack:							;xxx
-    and     bl, 0x05
-    cmp     bl, 0
+	; Look at control flags - expecting an ACK
-    je      ste_chkack
+	test	[edx + 20 + TCP_PACKET.Flags], TH_ACK
 	jz	.exit
-    ; It was a fin or reset.
-    ; Remove resend entries from the queue  - I dont want to send any more data
+	mov	[ebx + SOCKET.TCBState], TCB_ESTABLISHED
     pusha
-    mov     ebx, [sktAddr]
-    sub     ebx, sockets
+  .exit:
-    shr     ebx, 12             ; get skt #
+	ret
-    mov     esi, resendQ
-    mov     ecx, 0
+endp
-ste001:
-    cmp     ecx, NUMRESENDENTRIES
+proc stateTCB_ESTABLISHED stdcall, sockAddr:DWORD
-    je      ste003              ; None left
+	; Here we are expecting data, or a request to close
-    cmp     [esi], bl
-    je      ste002              ; found one
+	; OR both...
-    inc     ecx
-    add     esi, 4
+	; Did we receive a FIN or RST?
-    jmp     ste001
+;xxx    test    [edx + 20 + TCP_PACKET.Flags], TH_FIN + TH_RST
 ;xxx    jz      .check_ack
-ste002:
+	test	[edx + 20 + TCP_PACKET.Flags], TH_FIN		;xxx
-    dec     dword [arp_rx_count] ; ************ TEST ONLY!
+	jz	.check_ack					;xxx
     mov     [esi], byte 0xFF
-    jmp     ste001
 	; It was a fin or reset.
 ste003:
-    popa
+	; Remove resend entries from the queue  - I dont want to send any more data
 	pushad
     ; was it a reset?
-    mov     bl, [edx + 33]
+	; get skt #
-    and     bl, 0x04
+	stdcall net_socket_addr_to_num, ebx
-    cmp     bl, 0x04
-    jne     ste003a
+	mov	esi, resendQ
+	mov	ecx, 0
     mov     esi, [sktAddr]
-    mov     ebx, TCB_CLOSED
+  .next_resendq:
-    mov     [esi + 28], ebx
+	cmp	ecx, NUMRESENDENTRIES
-    jmp     ste_exit
+	je	.last_resendq	    ; None left
+	;cmp     [esi], al                                              ; XTODO: al -> eax
-ste003a:
+	cmp	[esi + 4], eax
-    ; Send an ACK to that fin, and enter closewait state
+	je	@f		    ; found one
 	inc	ecx
-    mov     esi, [sktAddr]
+	add	esi, 8
-    mov     ebx, TCB_CLOSE_WAIT
+	jmp	.next_resendq
-    mov     [esi + 28], ebx
     add     esi, 56
-    mov     eax, [esi]              ; save original
+    ;@@: mov     byte[esi], 0xff                                         ; XTODO: 0xff -> 0
-    call    inc_inet_esi
+    @@: mov	dword[esi + 4], 0
-    ;; jmp    ste_ack - NO, there may be data
+	inc	ecx
 	add	esi, 8
-ste_chkack:
+	jmp	.next_resendq
     ; Check that we received an ACK
-    mov     bl, [edx + 33]
+  .last_resendq:
-    and     bl, 0x10
+	popad
-    cmp     bl, 0x10
-    jnz     ste_exit
+;xxx    ; was it a reset?
+;xxx    test    [edx + 20 + TCP_PACKET.Flags], TH_RST
-    ; TODO - done, I think!
+;xxx    jz      @f
     ; 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
+;xxx    mov     [ebx + SOCKET.TCBState], TCB_CLOSED
-    ; queued.
+;xxx    jmp     .exit
-    ; ** I may need to tweak this value, since I do not know how many packets are already queued
-    mov     ch, [edx + 34]
-    mov     cl, [edx + 35]
+    @@: ; Send an ACK to that fin, and enter closewait state
     cmp     cx, 1024
-    ja      ste004
+	mov	[ebx + SOCKET.TCBState], TCB_CLOSE_WAIT
 	lea	esi, [ebx + SOCKET.RCV_NXT]
-    mov     ecx, [sktAddr]
+	mov	eax, [esi]		; save original
-    mov     [ecx+72], dword 1
+	call	inc_inet_esi
+	;; jmp    ste_ack - NO, there may be data
 ste004:
+  .check_ack:
-    ; OK, here is the deal
+	; Check that we received an ACK
-    ; My recv.nct field holds the seq of the expected next rec byte
+	test	[edx + 20 + TCP_PACKET.Flags], TH_ACK
-    ; if the recevied sequence number is not equal to this, do not
+	jz	.exit
-    ; increment the recv.nxt field, do not copy data - just send a
+	; TODO - done, I think!
-    ; repeat ack.
+	; 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.
-    ; recv.nxt is in dword [edx+24], in inext format
+	; ** I may need to tweak this value, since I do not know how many packets are already queued
-    ; recv seq is in [sktAddr]+56, in inet format
-    ; just do a comparision
+	mov	cx, [edx + 20 + TCP_PACKET.Window]
-    mov     ecx, [sktAddr]
-    add     ecx, 56
+	xchg	cl, ch
+	cmp	cx, 1024
-    cmp     [ecx - 56 + 28], dword TCB_CLOSE_WAIT
-    mov     ecx, [ecx]
+	ja	@f
-    jne     stenofin
+	mov	[ebx + SOCKET.wndsizeTimer], 1
-    mov     ecx, eax
+    @@: ; OK, here is the deal
+	; My recv.nct field holds the seq of the expected next rec byte
-stenofin:
-    cmp     ecx, [edx+24]
+	; if the recevied sequence number is not equal to this, do not
-    jne     ste_ack
+	; increment the recv.nxt field, do not copy data - just send a
 	; repeat ack.
-    ; Read the data bytes, store in socket buffer
+	; recv.nxt is in dword [edx+24], in inet format
-    xor     ecx, ecx
+	; recv seq is in [sktAddr]+56, in inet format
-    mov     ch, [edx + 2]
+	; just do a comparision
-    mov     cl, [edx + 3]
+	mov	ecx, [ebx + SOCKET.RCV_NXT]
-    sub     ecx, 40                    ; Discard 40 bytes of header
+	cmp	[ebx + SOCKET.TCBState], TCB_CLOSE_WAIT
+	jne	@f
+	mov	ecx, eax
-    cmp     ecx, 0
     jnz     ste_data                ; Read data, if any
-    ; If we had received a fin, we need to ACK it.
+    @@: cmp	ecx, [edx + 20 + TCP_PACKET.SequenceNumber]
-    mov     esi, [sktAddr]
+	jne	.ack
-    mov     ebx, [esi + 28]
-    cmp     ebx, TCB_CLOSE_WAIT
-    jz      ste_ack
-    jnz     ste_exit
+	; Read the data bytes, store in socket buffer
+	movzx	ecx, [edx + IP_PACKET.TotalLength]
-ste_data:
+	xchg	cl, ch
-    push    ecx
+	sub	ecx, 40 		   ; Discard 40 bytes of header
-    mov     esi, [sktAddr]
+	jnz	.data			   ; Read data, if any
-    add     [esi + 24], ecx      ; increment the count of bytes in buffer
+	; If we had received a fin, we need to ACK it.
+	cmp	[ebx + SOCKET.TCBState], TCB_CLOSE_WAIT
-    mov     eax, [esi + 4]       ; get socket owner PID
+	je	.ack
-    push    eax
+	jmp	.exit
-    mov     eax, [esi + 24]      ; get # of bytes already in buffer
-    ; point to the location to store the data
-    add     esi, eax
-    sub     esi, ecx
-    add     esi, SOCKETHEADERSIZE
-    add     edx, 40        ; edx now points to the data
-    mov     edi, esi
-    mov     esi, edx
   .data:
-    cld
+	push	ecx
-    rep     movsb          ; copy the data across
-    ; flag an event to the application
-    pop     eax
-    mov     ecx,1
-    mov     esi,TASK_DATA+TASKDATA.pid
+	add	[ebx + SOCKET.rxDataCount], ecx      ; increment the count of bytes in buffer
-news:
+	mov	eax, [ebx + SOCKET.PID]       ; get socket owner PID
-    cmp     [esi],eax
+	push	eax
     je      foundPID1
-    inc     ecx
+	mov	eax, [ebx + SOCKET.rxDataCount]      ; get # of bytes already in buffer
     add     esi,0x20
-    cmp     ecx,[TASK_COUNT]
+	; point to the location to store the data
-    jbe     news
+	lea	edi, [ebx + eax + SOCKETHEADERSIZE]
+	sub	edi, ecx
-foundPID1:
-    shl     ecx,8
-    or      dword [ecx+SLOT_BASE+APPDATA.event_mask],dword 10000000b ; stack event
+	add	edx, 40        ; edx now points to the data
-    pop     ecx
+	mov	esi, edx
-    ; Update our recv.nxt field
+	cld
-    mov     esi, [sktAddr]
-    add     esi, 56
+	rep	movsb	       ; copy the data across
     call    add_inet_esi
+	; flag an event to the application
-ste_ack:
+	pop	eax
-    ; Send an ACK
+	mov	ecx, 1
-    ; Now construct the response, and queue for sending by IP
+	mov	esi, TASK_DATA + TASKDATA.pid
-    mov     eax, EMPTY_QUEUE
-    call    dequeue
-    cmp     ax, NO_BUFFER
-    je      ste_exit
-    push    eax
-    mov     bl, 0x10        ; ACK
-    mov     ecx, 0
-    mov     esi, 0
-    call    buildTCPPacket
-    mov     eax, NET1OUT_QUEUE
-    mov     edx, [stack_ip]
-    mov     ecx, [ sktAddr ]
-    mov     ecx, [ ecx + 16 ]
+  .next_pid:
+	cmp	[esi], eax
-    cmp     edx, ecx
-    jne     ste_notlocal
+	je	.found_pid
-    mov     eax, IPIN_QUEUE
+	inc	ecx
-ste_notlocal:
+	add	esi, 0x20
 	cmp	ecx, [TASK_COUNT]
+	jbe	.next_pid
-       ; Send it.
-    pop     ebx
-    call    queue
+  .found_pid:
+	shl	ecx, 8
-ste_exit:
-    ret
+	or	[ecx + SLOT_BASE + APPDATA.event_mask], EVENT_NETWORK ; stack event
-stateTCB_FIN_WAIT_1:
-    ; We can either receive an ACK of a fin, or a fin
-    mov     bl, [edx + 33]
-    and     bl, 0x10
-    cmp     bl, 0x10
-    jnz     stfw1_001
-    ; It was an ACK
+	pop	ecx
     mov     esi, [sktAddr]
+	; Update our recv.nxt field
-    mov     ebx, TCB_FIN_WAIT_2
-    mov     [esi + 28], ebx
+	lea	esi, [ebx + SOCKET.RCV_NXT]
-    jmp     stfw1_exit
+	call	add_inet_esi
-stfw1_001:
-    ; It must be a fin then
-    mov     esi, [sktAddr]
+  .ack:
-    mov     ebx, TCB_CLOSING
-    mov     [esi + 28], ebx
-    add     esi, 56
+	; Send an ACK
+	; Now construct the response, and queue for sending by IP
+	mov	eax, EMPTY_QUEUE
-    call    inc_inet_esi
+	call	dequeue
+	cmp	ax, NO_BUFFER
-    ; Send an ACK
+	je	.exit
-    mov     eax, EMPTY_QUEUE
-    call    dequeue
+	push	eax
     cmp     ax, NO_BUFFER
+	mov	bl, TH_ACK
-    je      stfw1_exit
+	xor	ecx, ecx
-    push    eax
+	xor	esi, esi
+	stdcall build_tcp_packet, [sockAddr]
-    mov     bl, 0x10        ; ACK
-    mov     ecx, 0
+	mov	eax, NET1OUT_QUEUE

Subversion Repositories Kolibri OS

(root)/kernel/trunk/network/tcp.inc – Rev 871 → 907