WebSVN – Kolibri OS – Diff – /kernel/branches/kolibri_pe/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: 914 $
 TCB_FIN_WAIT_1     equ        5
 TCB_FIN_WAIT_2     equ        6
 TCB_CLOSE_WAIT     equ        7
 TCB_CLOSING        equ        8
 TCB_LAST_ACK       equ        9
-TCB_TIME_WAIT      equ        10
+TCB_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
 ;   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
-    mov     ecx, SOCKETHEADERSIZE
-    cld
+  .decrement_tcb:
-    rep     stosb
+    ; decrement it, delete socket if TCB timer = 0 & socket in timewait state
+	dec	[ebx + SOCKET.TCBTimer]
+	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     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
-    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
+	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
-    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:
+	mov	[esi + 4], ebx
     ; Mark it to expire in 10ms - 1 tick
-    mov     [esi+1], byte 1
+    @@: ; Mark it to expire in 10ms - 1 tick
-    mov     [esi+2], word 1
+	mov	byte[esi + 1], 1
-    jmp     tth005
+	mov	word[esi + 2], 1
 	jmp	.tth005
 tth004z:
-    ; we have a buffer # in ax
-    push    eax
+  .tth004z:
-    push    ecx
+    ; we have a buffer # in ax
-    mov     ecx, IPBUFFSIZE
-    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
+    pop     ecx
-    inc     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
+    @@: add	esi, IPBUFFSIZE
-tth004a:
+	loop	@b
-    add     esi, IPBUFFSIZE
-    loop    tth004a
     ; we have resend buffer location in esi
-    ; we have resend buffer location in esi
+    mov     ecx, IPBUFFSIZE
     mov     ecx, IPBUFFSIZE
     ; copy data across
-    ; copy data across
-    cld
+	push	edi
-    rep     movsb
+    cld
     rep     movsb
-    ; queue packet
+	pop	edi
+    ; queue packet
-    mov     eax, NET1OUT_QUEUE
     mov     edx, [stack_ip]
-    mov     ecx, [ edi + 16 ]
+    mov     eax, NET1OUT_QUEUE
     cmp     edx, ecx
 ;       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.
     ; 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
     ; 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]
-    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
-    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
+    ; 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
-    ; IP Packet SA = Remote IP
+	cmp	[ebx + SOCKET.Status], SOCK_OPEN
-    ; socket remote Port = 0
+	jne	.next_socket.2
-    mov     eax, SOCKETBUFFSIZE * NUM_SOCKETS
-    mov     ecx, NUM_SOCKETS
+;        DEBUGF  1, "K : tcp_rx - 2.dport: %x - %x\n", [edx + 20 + TCP_PACKET.DestinationPort]:4, [ebx + SOCKET.LocalPort]:4
-ss2:
-    sub     eax, SOCKETBUFFSIZE
+	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
-    movzx   ebx, word [edx + 22]     ; get the dest. port from the TCP hdr
+	jne	.next_socket.2				; different - try next socket
-    cmp     [eax + sockets + 12], bx ; compare with socket's local port
+;        DEBUGF  1, "K : tcp_rx - 2.addr: %x - %x\n", [edx + IP_PACKET.SourceAddress], [ebx + SOCKET.RemoteIP]
-    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
+	mov	ebx, net_sockets
+  .next_socket.3:
+	mov	ebx, [ebx + SOCKET.NextPtr]
+	or	ebx, ebx
+	jz	.next_socket.3.exit
+	cmp	[ebx + SOCKET.Status], SOCK_OPEN
+	jne	.next_socket.3
-nxttst2:
-    loop    ss2                     ; Return back if no match
-    ; If we got here, there was no match
-    ; Look for a socket where
-    ; IP Packet TCP Destination Port = local Port
-    ; socket Remote IP = 0
-    ; socket remote Port = 0
+;        DEBUGF  1, "K : tcp_rx - 3.dport: %x - %x\n", [edx + 20 + TCP_PACKET.DestinationPort]:4, [ebx + SOCKET.LocalPort]:4
-    mov     eax, SOCKETBUFFSIZE * NUM_SOCKETS
-    mov     ecx, NUM_SOCKETS
-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]
 ;       jne     .next_socket.4
-nxttst3:
+;
-    loop    ss3                     ; Return back if no match
+; .next_socket.4.exit:
 	inc	[dumped_rx_count]
-    ; If we got here, we need to reject the packet
+	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
     ; convert buffer pointer eax to the absolute address
     mov     ecx, IPBUFFSIZE
     mul     ecx
     add     eax, IPbuffs
     mov     edx, eax
-    mov     [edx + 33], bl            ; TCP flags
+	mov	[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
-    ; 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
-    shl     eax, 8
+    ret
-    inc     esi
+endp
     mov     al, [esi]
 ;   Description
 ;       TCP state machine
 ;       This is a kernel function, called by tcp_rx
+;
 ;       IP buffer address given in edx
-;          Socket/TCB address in [eax + sockets]
+;          Socket/TCB address in ebx
+;
 ;       The IP buffer will be released by the caller
 ;***************************************************************************
-tcpStateMachine:
-    mov     ebx, sockets
-    add     ebx, eax
-    mov     [sktAddr], ebx
 proc tcpStateMachine stdcall, sockAddr:DWORD
     ; as a packet has been received, update the TCB timer
-    mov     ecx, TWOMSL
-    mov     [ebx + 32], ecx
+	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
-    pusha
-    mov     cl, [edx + 33]
-    and     cl, 0x10
+	pushad
-    cmp     cl, 0x10
-    jne     tsm001                      ; No ACK, so no data yet
+	test	[edx + 20 + TCP_PACKET.Flags], TH_ACK
+	jz	.call_handler					; No ACK, so no data yet
-    ; get skt number in al
+	; get skt number in eax
-    shr     eax, 12
+	stdcall net_socket_addr_to_num, ebx
     ; The ack number is in [edx + 28], inet format
-    ; skt in al
+	; skt in eax
+    mov     esi, resendQ
-    mov     esi, resendQ
+	xor	ecx, ecx
-    mov     ecx, 0
   .next_resendq:
-t001:
+    cmp     ecx, NUMRESENDENTRIES
-    cmp     ecx, NUMRESENDENTRIES
+	je	.call_handler	  ; None left
-    je      t003              ; None left
+	;cmp     [esi], al                                       ; XTODO: al -> eax
-    cmp     [esi], al
+	cmp	[esi + 4], eax
-    je      t002              ; found one
+	je	@f		  ; found one
     inc     ecx
-    add     esi, 4
-    jmp     t001
+	add	esi, 8
-t002:                   ; Can we delete this buffer?
+	jmp	.next_resendq
-                        ; If yes, goto t004. No, goto t001
-    ; Get packet data address
+    @@: 		  ; Can we delete this buffer?
-    push    ecx
+			  ; If yes, goto @@. No, goto .next_resendq
-    inc     ecx
-    ; Now get buffer location, and copy buffer across. argh! more copying,,
+    ; Get packet data address
-    mov     edi, resendBuffer - IPBUFFSIZE
-t002a:
-    add     edi, IPBUFFSIZE
-    loop    t002a
-    ; we have dest buffer location in edi. incoming packet in edx.
-    ; Get this packets sequence number
+    push    ecx
-    ; preserve al, ecx, esi, edx
+    ; Now get buffer location, and copy buffer across. argh! more copying,,
 	imul	edi, ecx, IPBUFFSIZE
-    mov     cl, [edi + 24]
+	add	edi, resendBuffer
     shl     ecx, 8
-    mov     cl, [edi + 25]
-    shl     ecx, 8
-    mov     cl, [edi + 26]
+    ; we have dest buffer location in edi. incoming packet in edx.
-    shl     ecx, 8
+    ; Get this packets sequence number
-    mov     cl, [edi + 27]
-    movzx   ebx, byte [edi + 3]
-    mov     bh, [edi + 2]
-    sub     ebx, 40
+    ; preserve al, ecx, esi, edx
-    add     ecx, ebx          ; ecx is now seq# of last byte +1, intel format
+	mov	ecx, [edi + 20 + TCP_PACKET.SequenceNumber]
 	bswap	ecx
-    ; get recievd ack #, in intel format
+	movzx	ebx, word[edi + 2]
+	xchg	bl, bh
-    mov     bl, [edx + 28]
-    shl     ebx, 8
+    sub     ebx, 40
-    mov     bl, [edx + 29]
+    add     ecx, ebx          ; ecx is now seq# of last byte +1, intel format
-    shl     ebx, 8
-    mov     bl, [edx + 30]
-    shl     ebx, 8
-    mov     bl, [edx + 31]
+    ; get recievd ack #, in intel format
-    cmp     ebx, ecx        ; Finally. ecx = rx'ed ack. ebx = last byte in que
+	mov	ebx, [edx + 20 + TCP_PACKET.AckNumber]
-                            ; DANGER! need to handle case that we have just
+	bswap	ebx
-                            ; passed the 2**32, and wrapped round!
-    pop     ecx
+    cmp     ebx, ecx        ; Finally. ecx = rx'ed ack. ebx = last byte in que
-    jae     t004             ; if rx > old, delete old
-    inc     ecx
+                            ; DANGER! need to handle case that we have just
-    add     esi, 4
+                            ; passed the 2**32, and wrapped round!
-    jmp     t001
+    pop     ecx
-t004:
-    dec     dword [arp_rx_count] ; ************ TEST ONLY!
+	jae	@f		; if rx > old, delete old
-    mov     [esi], byte 0xFF
+    inc     ecx
-    inc     ecx
+	add	esi, 8
+	jmp	.next_resendq
-    add     esi, 4
-    jmp     t001
+    ;@@: mov     byte[esi], 0xff                                 ; XTODO: 0xff -> 0
+    @@: mov	dword[esi + 4], 0
+    inc     ecx
+	add	esi, 8
-t003:
+	jmp	.next_resendq
-tsm001:
+  .call_handler:
-    popa
+	popad
-    ; Call handler for given TCB state
-    mov     ebx, [eax + sockets+28]
-    cmp     ebx, TCB_LISTEN
+	; Call handler for given TCB state
     jb      tsm_exit
-    cmp     ebx, TCB_CLOSED
+	mov	eax, [ebx + SOCKET.TCBState]
-    ja      tsm_exit
+	cmp	eax, TCB_LISTEN
+	jb	.exit
-    dec     ebx
+	cmp	eax, TCB_CLOSED
-    call    dword [TCBStateHandler+ebx*4]
+	ja	.exit
-tsm_exit:
+	stdcall [TCBStateHandler + (eax - 1) * 4], [sockAddr]
-    ret
+  .exit:
-stateTCB_LISTEN:
+    ret
-    ; In this case, we are expecting a SYN packet
+endp
-    ; For now, if the packet is a SYN, process it, and send a response
     ; If not, ignore it
 proc stateTCB_LISTEN stdcall, sockAddr:DWORD
-    ; Look at control flags
+    ; In this case, we are expecting a SYN packet
-    mov     bl, [edx + 33]
+    ; For now, if the packet is a SYN, process it, and send a response
-    and     bl, 0x02
+    ; If not, ignore it
     cmp     bl, 0x02
-    jnz     stl_exit
+    ; Look at control flags
+	test	[edx + 20 + TCP_PACKET.Flags], TH_SYN
-    ; We have a SYN. update the socket with this IP packets details,
+	jz	.exit
-    ; And send a response
-    mov     ebx, [edx + 12] ; IP source address
+    ; We have a SYN. update the socket with this IP packets details,
-    mov     [eax + sockets + 16], ebx
+    ; And send a response
-    mov     bx, [edx + 20] ; IP source port
-    mov     [eax + sockets + 20], bx
+	mov	eax, [edx + IP_PACKET.SourceAddress]
-    mov     ebx, [edx + 24] ; IRS
-    mov     [eax + sockets + 40], ebx
+	mov	[ebx + SOCKET.RemoteIP], eax
-    mov     [eax + sockets + 56], ebx
+	mov	ax, [edx + 20 + TCP_PACKET.SourcePort]
-    mov     esi, sockets
+	mov	[ebx + SOCKET.RemotePort], ax
-    add     esi, eax
+	mov	eax, [edx + 20 + TCP_PACKET.SequenceNumber]
-    add     esi, 56
+	mov	[ebx + SOCKET.IRS], eax
-    call    inc_inet_esi ; RCV.NXT
+	mov	[ebx + SOCKET.RCV_NXT], eax
+	lea	esi, [ebx + SOCKET.RCV_NXT]
+    call    inc_inet_esi ; RCV.NXT
-    mov     ebx, [eax + sockets + 36]    ; ISS
-    mov     [eax + sockets + 48], ebx    ; SND.NXT
-    ; Now construct the response, and queue for sending by IP
-    mov     eax, EMPTY_QUEUE
+	mov	eax, [ebx + SOCKET.ISS]
-    call    dequeue
+	mov	[ebx + SOCKET.SND_NXT], eax
     cmp     ax, NO_BUFFER
-    je      stl_exit
+    ; Now construct the response, and queue for sending by IP
     mov     eax, EMPTY_QUEUE
+    call    dequeue
-    push    eax
-    mov     bl, 0x12        ; SYN + ACK
+    cmp     ax, NO_BUFFER
-    mov     ecx, 0
+	je	.exit
     mov     esi, 0
-    call    buildTCPPacket
-    mov     eax, NET1OUT_QUEUE
-    mov     edx, [stack_ip]
-    mov     ecx, [ sktAddr ]
-    mov     ecx, [ ecx + 16 ]
-    cmp     edx, ecx
+    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
     jne     stl_notlocal
-    mov     eax, IPIN_QUEUE
+	mov	esi, [sockAddr]
 	mov	[esi + SOCKET.TCBState], TCB_SYN_RECEIVED
-stl_notlocal:
-       ; Send it.
-    pop     ebx
+	; increment SND.NXT in socket
-    call    queue
+	add	esi, SOCKET.SND_NXT
     call    inc_inet_esi
-    mov     ebx, TCB_SYN_RECEIVED
+  .exit:
-    mov     esi, [sktAddr]
+    ret
-    mov     [esi + 28], ebx
+endp
-    ; increament SND.NXT in socket
+proc stateTCB_SYN_SENT stdcall, sockAddr:DWORD
-    add     esi, 48
-    call    inc_inet_esi
+    ; We are awaiting an ACK to our SYN, with a SYM
+    ; Look at control flags - expecting an ACK
-stl_exit:
-    ret
 	mov	al, [edx + 20 + TCP_PACKET.Flags]
 	and	al, TH_SYN + TH_ACK
+	cmp	al, TH_SYN + TH_ACK
-stateTCB_SYN_SENT:
+	je	.syn_ack
-    ; We are awaiting an ACK to our SYN, with a SYM
-    ; Look at control flags - expecting an ACK
-    mov     bl, [edx + 33]
+	test	al, TH_SYN
-    and     bl, 0x12
+	jz	.exit
     cmp     bl, 0x12
-    jnz     stss_exit
+	mov	[ebx + SOCKET.TCBState], TCB_SYN_RECEIVED
 	push	TH_SYN + TH_ACK
-    mov     ebx, TCB_ESTABLISHED
+	jmp	.send
     mov     esi, [sktAddr]
+  .syn_ack:
-    mov     [esi + 28], ebx
+	mov	[ebx + SOCKET.TCBState], TCB_ESTABLISHED
-    ; Store the recv.nxt field
+	push	TH_ACK
     mov     eax, [edx + 24]
   .send:
+    ; Store the recv.nxt field
+	mov	eax, [edx + 20 + TCP_PACKET.SequenceNumber]
+    ; Update our recv.nxt field
+	mov	[ebx + SOCKET.RCV_NXT], eax
+	lea	esi, [ebx + SOCKET.RCV_NXT]
+    call    inc_inet_esi
+    ; Send an ACK
+    ; Now construct the response, and queue for sending by IP
-    ; Update our recv.nxt field
+    mov     eax, EMPTY_QUEUE
-    mov     esi, [sktAddr]
+    call    dequeue
-    add     esi, 56
-    mov     [esi], eax
-    call    inc_inet_esi
+    cmp     ax, NO_BUFFER
-    ; Send an ACK
-    ; Now construct the response, and queue for sending by IP
-    mov     eax, EMPTY_QUEUE
-    call    dequeue
+	pop	ebx
-    cmp     ax, NO_BUFFER
+	je	.exit
+    push    eax
-    je      stss_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
-    mov     esi, 0
+    mov     edx, [stack_ip]
-    call    buildTCPPacket
+	mov	ecx, [sockAddr]
 	cmp	edx, [ecx + SOCKET.RemoteIP]
-    mov     eax, NET1OUT_QUEUE
+	jne	.not_local
-    mov     edx, [stack_ip]
+    mov     eax, IPIN_QUEUE
-    mov     ecx, [ sktAddr ]
-    mov     ecx, [ ecx + 16 ]
+  .not_local:
-    cmp     edx, ecx
+       ; Send it.
-    jne     stss_notlocal
+    pop     ebx
-    mov     eax, IPIN_QUEUE
+    call    queue
+  .exit:
-stss_notlocal:
+    ret
-       ; Send it.
+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
     pop     ebx
-    call    queue
+	test	[edx + 20 + TCP_PACKET.Flags], TH_RST		;xxx
+	jz	.check_ack					;xxx
+	push	[ebx + SOCKET.OrigRemotePort] [ebx + SOCKET.OrigRemoteIP]
+	pop	[ebx + SOCKET.RemoteIP] [ebx + SOCKET.RemotePort]
+	mov	[ebx + SOCKET.TCBState], TCB_LISTEN		;xxx
+	jmp	.exit						;xxx
-stss_exit:
-    ret
+  .check_ack:							;xxx
+    ; Look at control flags - expecting an ACK
+	test	[edx + 20 + TCP_PACKET.Flags], TH_ACK
-stateTCB_SYN_RECEIVED:
-    ; In this case, we are expecting an ACK packet
-    ; For now, if the packet is an ACK, process it,
-    ; If not, ignore it
-    ; Look at control flags - expecting an ACK
-    mov     bl, [edx + 33]
-    and     bl, 0x10
-    cmp     bl, 0x10
-    jnz     stsr_exit
-    mov     ebx, TCB_ESTABLISHED
-    mov     esi, [sktAddr]
-    mov     [esi + 28], ebx
-stsr_exit:
-    ret
+	jz	.exit
-stateTCB_ESTABLISHED:
+	mov	[ebx + SOCKET.TCBState], TCB_ESTABLISHED
     ; Here we are expecting data, or a request to close
-    ; OR both...
+  .exit:
+    ret
-    ; Did we receive a FIN or RST?
+endp
-    mov     bl, [edx + 33]
-    and     bl, 0x05
-    cmp     bl, 0
-    je      ste_chkack
-    ; It was a fin or reset.
+proc stateTCB_ESTABLISHED stdcall, sockAddr:DWORD
     ; Here we are expecting data, or a request to close
-    ; Remove resend entries from the queue  - I dont want to send any more data
+    ; OR both...
-    pusha
-    mov     ebx, [sktAddr]
+    ; Did we receive a FIN or RST?
-    sub     ebx, sockets
+;xxx    test    [edx + 20 + TCP_PACKET.Flags], TH_FIN + TH_RST
-    shr     ebx, 12             ; get skt #
+;xxx    jz      .check_ack
+	test	[edx + 20 + TCP_PACKET.Flags], TH_FIN		;xxx
-    mov     esi, resendQ
-    mov     ecx, 0
-ste001:
+	jz	.check_ack					;xxx
-    cmp     ecx, NUMRESENDENTRIES
-    je      ste003              ; None left
+    ; It was a fin or reset.
     cmp     [esi], bl
-    je      ste002              ; found one
+    ; Remove resend entries from the queue  - I dont want to send any more data
-    inc     ecx
+	pushad
-    add     esi, 4
-    jmp     ste001
+	; get skt #
 	stdcall net_socket_addr_to_num, ebx
-ste002:
-    dec     dword [arp_rx_count] ; ************ TEST ONLY!
-    mov     [esi], byte 0xFF
+    mov     esi, resendQ
-    jmp     ste001
+    mov     ecx, 0
 ste003:
-    popa
+  .next_resendq:
-    ; was it a reset?
+    cmp     ecx, NUMRESENDENTRIES
-    mov     bl, [edx + 33]
+	je	.last_resendq	    ; None left
-    and     bl, 0x04
-    cmp     bl, 0x04
+	;cmp     [esi], al                                              ; XTODO: al -> eax
-    jne     ste003a
+	cmp	[esi + 4], eax
 	je	@f		    ; found one
-    mov     esi, [sktAddr]
-    mov     ebx, TCB_CLOSED
-    mov     [esi + 28], ebx
+	inc	ecx
-    jmp     ste_exit
+	add	esi, 8
-ste003a:
-    ; Send an ACK to that fin, and enter closewait state
+	jmp	.next_resendq
-    mov     esi, [sktAddr]
+    ;@@: mov     byte[esi], 0xff                                         ; XTODO: 0xff -> 0
-    mov     ebx, TCB_CLOSE_WAIT
+    @@: mov	dword[esi + 4], 0
-    mov     [esi + 28], ebx
+    inc     ecx
-    add     esi, 56
-    mov     eax, [esi]              ; save original
+	add	esi, 8
-    call    inc_inet_esi
+	jmp	.next_resendq
     ;; jmp    ste_ack - NO, there may be data
+  .last_resendq:
-ste_chkack:
+	popad
-    ; Check that we received an ACK
-    mov     bl, [edx + 33]
+;xxx    ; was it a reset?
-    and     bl, 0x10
-    cmp     bl, 0x10
+;xxx    test    [edx + 20 + TCP_PACKET.Flags], TH_RST
-    jnz     ste_exit
 ;xxx    jz      @f
-    ; TODO - done, I think!
+;xxx    mov     [ebx + SOCKET.TCBState], TCB_CLOSED
-    ; First, look at the incoming window. If this is less than or equal to 1024,
+;xxx    jmp     .exit
     ; Set the socket window timer to 1. This will stop an additional packets being
-    ; queued.
+    @@: ; Send an ACK to that fin, and enter closewait state
     ; ** I may need to tweak this value, since I do not know how many packets are already queued
-    mov     ch, [edx + 34]
+	mov	[ebx + SOCKET.TCBState], TCB_CLOSE_WAIT
-    mov     cl, [edx + 35]
+	lea	esi, [ebx + SOCKET.RCV_NXT]
-    cmp     cx, 1024
+    mov     eax, [esi]              ; save original
-    ja      ste004
+    call    inc_inet_esi
     ;; jmp    ste_ack - NO, there may be data
     mov     ecx, [sktAddr]
-    mov     [ecx+72], dword 1
+  .check_ack:
+    ; Check that we received an ACK
-ste004:
+	test	[edx + 20 + TCP_PACKET.Flags], TH_ACK
+	jz	.exit
     ; OK, here is the deal
-    ; My recv.nct field holds the seq of the expected next rec byte
+    ; TODO - done, I think!
-    ; if the recevied sequence number is not equal to this, do not
+    ; First, look at the incoming window. If this is less than or equal to 1024,
-    ; increment the recv.nxt field, do not copy data - just send a
-    ; repeat ack.
+	; 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
-    ; recv.nxt is in dword [edx+24], in inext format
+	mov	cx, [edx + 20 + TCP_PACKET.Window]
-    ; recv seq is in [sktAddr]+56, in inet format
+	xchg	cl, ch
-    ; just do a comparision
+    cmp     cx, 1024
-    mov     ecx, [sktAddr]
+	ja	@f
     add     ecx, 56
+	mov	[ebx + SOCKET.wndsizeTimer], 1
     cmp     [ecx - 56 + 28], dword TCB_CLOSE_WAIT
-    mov     ecx, [ecx]
+    @@: ; OK, here is the deal
-    jne     stenofin
+    ; My recv.nct field holds the seq of the expected next rec byte
-    mov     ecx, eax
+    ; if the recevied sequence number is not equal to this, do not
-stenofin:
+    ; increment the recv.nxt field, do not copy data - just send a
-    cmp     ecx, [edx+24]
+    ; repeat ack.
     jne     ste_ack
+	; recv.nxt is in dword [edx+24], in inet format
+    ; recv seq is in [sktAddr]+56, in inet format
-    ; Read the data bytes, store in socket buffer
-    xor     ecx, ecx
+    ; just do a comparision
-    mov     ch, [edx + 2]
+	mov	ecx, [ebx + SOCKET.RCV_NXT]
-    mov     cl, [edx + 3]
+	cmp	[ebx + SOCKET.TCBState], TCB_CLOSE_WAIT
-    sub     ecx, 40                    ; Discard 40 bytes of header
+	jne	@f
     mov     ecx, eax
     cmp     ecx, 0
-    jnz     ste_data                ; Read data, if any
+    @@: cmp	ecx, [edx + 20 + TCP_PACKET.SequenceNumber]
 	jne	.ack
-    ; If we had received a fin, we need to ACK it.
-    mov     esi, [sktAddr]
-    mov     ebx, [esi + 28]
+    ; Read the data bytes, store in socket buffer
-    cmp     ebx, TCB_CLOSE_WAIT
+	movzx	ecx, [edx + IP_PACKET.TotalLength]
-    jz      ste_ack
+	xchg	cl, ch
+    sub     ecx, 40                    ; Discard 40 bytes of header
-    jnz     ste_exit
+	jnz	.data			   ; Read data, if any
-ste_data:
+    ; If we had received a fin, we need to ACK it.
-    push    ecx
-    mov     esi, [sktAddr]
+	cmp	[ebx + SOCKET.TCBState], TCB_CLOSE_WAIT
-    add     [esi + 24], ecx      ; increment the count of bytes in buffer
+	je	.ack
+	jmp	.exit
-    mov     eax, [esi + 4]       ; get socket owner PID
-    push    eax
+  .data:
+    push    ecx
-    mov     eax, [esi + 24]      ; get # of bytes already in buffer
+	add	[ebx + SOCKET.rxDataCount], ecx      ; increment the count of bytes in buffer
-    ; point to the location to store the data
-    add     esi, eax
+	mov	eax, [ebx + SOCKET.PID]       ; get socket owner PID
-    sub     esi, ecx
+    push    eax
     add     esi, SOCKETHEADERSIZE
 	mov	eax, [ebx + SOCKET.rxDataCount]      ; get # of bytes already in buffer
     add     edx, 40        ; edx now points to the data
-    mov     edi, esi
+    ; point to the location to store the data
-    mov     esi, edx
+	lea	edi, [ebx + eax + SOCKETHEADERSIZE]
+	sub	edi, ecx
-    cld
-    rep     movsb          ; copy the data across
+    add     edx, 40        ; edx now points to the data
+    mov     esi, edx
     ; flag an event to the application
-    pop     eax
+    cld
-    mov     ecx,1
+    rep     movsb          ; copy the data across
-    mov     esi,TASK_DATA+TASKDATA.pid
-news:
+    ; flag an event to the application
-    cmp     [esi],eax
+    pop     eax
-    je      foundPID1
+	mov	ecx, 1
-    inc     ecx
+	mov	esi, TASK_DATA + TASKDATA.pid
     add     esi,0x20
-    cmp     ecx,[TASK_COUNT]
+  .next_pid:
-    jbe     news
+	cmp	[esi], eax
 	je	.found_pid
+    inc     ecx
-foundPID1:
-    shl     ecx,8
+	add	esi, 0x20
-    or      dword [ecx+SLOT_BASE+APPDATA.event_mask],dword 10000000b ; stack event
+	cmp	ecx, [TASK_COUNT]
-    pop     ecx
-    ; Update our recv.nxt field
-    mov     esi, [sktAddr]
-    add     esi, 56
+	jbe	.next_pid
-    call    add_inet_esi
-ste_ack:
-    ; Send an ACK
-    ; Now construct the response, and queue for sending by IP
     mov     eax, EMPTY_QUEUE
-    call    dequeue
+  .found_pid:
-    cmp     ax, NO_BUFFER
-    je      ste_exit
-    push    eax
+	shl	ecx, 8
-    mov     bl, 0x10        ; ACK
+	or	[ecx + SLOT_BASE + APPDATA.event_mask], EVENT_NETWORK ; stack event
     mov     ecx, 0
-    mov     esi, 0
+    pop     ecx
-    call    buildTCPPacket
+    ; Update our recv.nxt field
+	lea	esi, [ebx + SOCKET.RCV_NXT]
-    mov     eax, NET1OUT_QUEUE
+    call    add_inet_esi
-    mov     edx, [stack_ip]
+  .ack:
-    mov     ecx, [ sktAddr ]
+    ; Send an ACK
-    mov     ecx, [ ecx + 16 ]
-    cmp     edx, ecx
+    ; Now construct the response, and queue for sending by IP
-    jne     ste_notlocal
+    mov     eax, EMPTY_QUEUE
-    mov     eax, IPIN_QUEUE
+    call    dequeue
-ste_notlocal:
+    cmp     ax, NO_BUFFER
+	je	.exit
-       ; Send it.
-    pop     ebx
-    call    queue
+    push    eax
-ste_exit:
+	mov	bl, TH_ACK
-    ret
+	xor	ecx, ecx
 	xor	esi, esi
-stateTCB_FIN_WAIT_1:
-    ; We can either receive an ACK of a fin, or a fin
-    mov     bl, [edx + 33]
-    and     bl, 0x10
-    cmp     bl, 0x10
-    jnz     stfw1_001
-    ; It was an ACK
-    mov     esi, [sktAddr]
-    mov     ebx, TCB_FIN_WAIT_2
-    mov     [esi + 28], ebx
-    jmp     stfw1_exit
-stfw1_001:
-    ; It must be a fin then
+	stdcall build_tcp_packet, [sockAddr]
     mov     esi, [sktAddr]
+    mov     eax, NET1OUT_QUEUE
-    mov     ebx, TCB_CLOSING
-    mov     [esi + 28], ebx
-    add     esi, 56
+    mov     edx, [stack_ip]
-    call    inc_inet_esi
+	mov	ecx, [sockAddr]
 	cmp	edx, [ecx + SOCKET.RemoteIP]
+	jne	.not_local
-    ; Send an ACK
-    mov     eax, EMPTY_QUEUE
+    mov     eax, IPIN_QUEUE
     call    dequeue
-    cmp     ax, NO_BUFFER
+  .not_local:
-    je      stfw1_exit
-    push    eax
+       ; Send it.
-    mov     bl, 0x10        ; ACK
-    mov     ecx, 0
+    pop     ebx
-    mov     esi, 0
-    call    buildTCPPacket
-    mov     eax, NET1OUT_QUEUE
-    mov     edx, [stack_ip]
-    mov     ecx, [ sktAddr ]
+    call    queue
     mov     ecx, [ ecx + 16 ]
+  .exit:
-    cmp     edx, ecx
-    jne     stfw1_notlocal
+    ret
-    mov     eax, IPIN_QUEUE
+endp
-stfw1_notlocal:
-    ; Send it.
-    pop     ebx
-    call    queue
-stfw1_exit:
+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]
-    ret
+	and	al, TH_FIN + TH_ACK
+	cmp	al, TH_ACK
+	jne	@f
-stateTCB_FIN_WAIT_2:
-    mov     esi, [sktAddr]
+    ; It was an ACK
+	mov	[ebx + SOCKET.TCBState], TCB_FIN_WAIT_2
-    ; Get data length
+	jmp	.exit
     xor     ecx, ecx
+    @@: mov	[ebx + SOCKET.TCBState], TCB_CLOSING
-    mov     ch, [edx+2]
-    mov     cl, [edx+3]
+	cmp	al, TH_FIN
-    sub     ecx, 40
+	je	@f
+	mov	[ebx + SOCKET.TCBState], TCB_TIMED_WAIT

Subversion Repositories Kolibri OS

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