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

 ;;             Version 2, June 1991                                ;;
 ;;                                                                 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 $Revision: 1206 $
 $Revision: 1249 $
 ; TCP TCB states
 TCB_LISTEN		equ 1
 TCB_CLOSING		equ 8
 TCB_LAST_ACK		equ 9
 TCB_TIMED_WAIT		equ 10
 TCB_CLOSED		equ 11
-TH_FIN			equ 0x01
+TH_FIN			equ 1 shl 0
-TH_SYN			equ 0x02
+TH_SYN			equ 1 shl 1
-TH_RST			equ 0x04
+TH_RST			equ 1 shl 2
-TH_PUSH 		equ 0x08
+TH_PUSH 		equ 1 shl 3
-TH_ACK			equ 0x10
+TH_ACK			equ 1 shl 4
-TH_URG			equ 0x20
+TH_URG			equ 1 shl 5
 TWOMSL			equ 10		; # of secs to wait before closing socket
+TCP_RETRIES		equ 5		; Number of times to resend a Packet
-TCP_RETRIES		equ 5		; Number of times to resend a Packet
+TCP_TIMEOUT		equ 10		; resend if not replied to in 1/100 s
 TCP_TIMEOUT		equ 10		; resend if not replied to in x hs
 TCP_QUEUE_SIZE		equ 16
 TCP_QUEUE_SIZE		equ 16
 align 4
 uglobal
 	TCP_PACKETS_TX		rd  MAX_IP
 	TCP_PACKETS_RX		rd  MAX_IP
-	TCP_IN_QUEUE	rd  3*TCP_QUEUE_SIZE+3
+	TCP_IN_QUEUE		rd  (tcp_in_queue_entry.size*TCP_QUEUE_SIZE+queue.data)/4
+	TCP_OUT_QUEUE		dd ?
-	TCP_OUT_QUEUE	rd  3*TCP_QUEUE_SIZE+3
+				rd  (tcp_out_queue_entry.size*TCP_QUEUE_SIZE)/4
+endg
+align 4
+iglobal
+TCBStateHandler:
+  dd  stateTCB_LISTEN
+  dd  stateTCB_SYN_SENT
+  dd  stateTCB_SYN_RECEIVED
+  dd  stateTCB_ESTABLISHED
+  dd  stateTCB_FIN_WAIT_1
+  dd  stateTCB_FIN_WAIT_2
+  dd  stateTCB_CLOSE_WAIT
+  dd  stateTCB_CLOSING
+  dd  stateTCB_LAST_ACK
+  dd  stateTCB_TIME_WAIT
+  dd  stateTCB_CLOSED
+endg
+macro inc_INET reg {
+	inc	byte [reg + 0]
+	adc	byte [reg + 1], 0
+	adc	byte [reg + 2], 0
+	adc	byte [reg + 3], 0
+}
+macro add_INET reg {
+	rol	ecx, 16
+	adc	byte [reg + 0], ch
+	adc	byte [reg + 1], cl
+	rol	ecx, 16
+	adc	byte [reg + 2], ch
+	adc	byte [reg + 3], cl
 endg
 	xor	eax, eax
 	mov	edi, TCP_PACKETS_TX
 	mov	ecx, 2*MAX_IP
 	rep	stosd
-	mov	dword [TCP_IN_QUEUE], TCP_QUEUE_SIZE
-	mov	dword [TCP_IN_QUEUE+4], TCP_IN_QUEUE + queue.data
-	mov	dword [TCP_IN_QUEUE+8], TCP_IN_QUEUE + queue.data
+	init_queue TCP_IN_QUEUE
-	mov	dword [TCP_OUT_QUEUE], TCP_QUEUE_SIZE
-	mov	dword [TCP_OUT_QUEUE+4], TCP_OUT_QUEUE + queue.data
-	mov	dword [TCP_OUT_QUEUE+8], TCP_OUT_QUEUE + queue.data
+	init_queue TCP_OUT_QUEUE
 	ret
 ;-----------------------------------------------------------------
 ;
-;      tcp_tcb_handler
+;  TCP_decrease_socket_ttls
+;
-;       Handles sockets in the timewait state, closing them
+;  IN:  /
-;       when the TCB timer expires
+;  OUT: /
+;
 ;-----------------------------------------------------------------
 align 4
-tcp_tcb_handler:
-	; scan through all the sockets, decrementing active timers
+TCP_decrease_socket_ttls:
+	; scan through all the sockets, decrementing active timers
 	mov	ebx, net_sockets
 	mov	ebx, net_sockets
+	cmp	[ebx + SOCKET_head.NextPtr], 0
+	je	.exit
 	cmp	[ebx + SOCKET.NextPtr], 0
-	je	.exit
+  .next_socket:
-	DEBUGF	1, "K : sockets:\n"
+	mov	ebx, [ebx + SOCKET_head.NextPtr]
+	or	ebx, ebx
-  .next_socket:
+	jz	.exit
 	mov	ebx, [ebx + SOCKET.NextPtr]
-	or	ebx, ebx
+	cmp	[ebx + SOCKET_head.Type], IP_PROTO_TCP
-	jz	.exit
+	jne	.next_socket
 ;        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
+	cmp	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.TCBTimer], 0
 	jne	.decrement_tcb
-	cmp	[ebx + SOCKET.wndsizeTimer], 0
+	cmp	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_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]
+	dec	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.TCBTimer]
 	jnz	.next_socket
+	cmp	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.TCBState], TCB_TIMED_WAIT
-	cmp	[ebx + SOCKET.TCBState], TCB_TIMED_WAIT
+	jne	.next_socket
-	jne	.next_socket
+	push	[ebx + SOCKET_head.PrevPtr]
-	push	[ebx + SOCKET.PrevPtr]
+	stdcall net_socket_free, ebx
-	stdcall net_socket_free, ebx
+	pop	ebx
-	pop	ebx
+	jmp	.next_socket
-	jmp	.next_socket
+  .decrement_wnd:
+	; TODO - prove it works!
+	dec	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.wndsizeTimer]
 	jmp	.next_socket
-  .decrement_wnd:
-	; TODO - prove it works!
+  .exit:
-	dec	[ebx + SOCKET.wndsizeTimer]
-	jmp	.next_socket
-  .exit:
-	ret
-;***************************************************************************
-;   Function
+	ret
-;      tcp_tx_handler
-;
-;   Description
-;       Handles queued TCP data
-;       This is a kernel function, called by stack_handler
-;
-;***************************************************************************
-align 4
-tcp_tx_handler:
-    ; decrement all resend buffers timers. If they
-    ; expire, queue them for sending, and restart the timer.
-    ; If the retries counter reach 0, delete the entry
-	mov	esi, resendQ
-	mov	ecx, 0
-  .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
+; TCP_send_queued:
-    @@: ; Mark it to expire in 10ms - 1 tick
+;
-	mov	byte[esi + 1], 1
+;  Decreases 'ttl' of tcp packets queued.
-	mov	word[esi + 2], 1
-	jmp	.tth005
+;  if 'ttl' reaches 0, resend the packet and decrease 'retries'
+;  if 'retries' reaches zero, remove the queued packet
-  .tth004z:
-	; we have a buffer # in ax
+;
-;        push    eax ecx
+;  IN:  /
-;        mov     ecx, IPBUFFSIZE
+;  OUT: /
-;        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,,
+;
+;-----------------------------------------------------------------
+align 4
-;        mov     esi, resendBuffer
+TCP_send_queued:
-;    @@: add     esi, IPBUFFSIZE
+	cmp	[TCP_OUT_QUEUE], 0
-	loop	@b
+	je	.exit
-	; we have resend buffer location in esi
+	mov	eax, TCP_QUEUE_SIZE
-;        mov     ecx, IPBUFFSIZE
+	mov	ecx, [TCP_OUT_QUEUE]
+	mov	esi, TCP_OUT_QUEUE+4
+  .loop:
+	cmp	[esi + tcp_out_queue_entry.data_ptr], 0
+	jnz	.found_one
+	add	esi, tcp_out_queue_entry.size
+	loop	.loop
+  .exit:
+	ret
-	; copy data across
+  .found_one:
+	dec	[esi + tcp_out_queue_entry.ttl]
+	jz	.send_it
+  .find_next:
+	dec	eax
-	push	edi
+	jz	.exit
-	cld
+	jmp	.loop
 	rep	movsb
-	pop	edi
+  .send_it:
 	push	eax ecx esi
-	; queue Packet
-;        mov     eax, NET1OUT_QUEUE
-;        mov     edx, [IP_LIST]
+	push	[esi + tcp_out_queue_entry.data_size]
-;        cmp     edx, [edi + IP_Packet.DestinationAddress]
+	push	[esi + tcp_out_queue_entry.data_ptr]
-;        jne     .not_local
+	mov	ebx, [esi + tcp_out_queue_entry.owner]
-;        mov     eax, IPIN_QUEUE
+	call	[esi + tcp_out_queue_entry.sendproc]
-  .not_local:
-	pop	ebx
-;        call    queue
+	pop	esi ecx eax
-  .tth005:
+	dec	[esi + tcp_out_queue_entry.retries]
+	jz	.remove_it
-	popad
+	mov	[esi + tcp_out_queue_entry.ttl], TCP_TIMEOUT
-	inc	ecx
+	jmp	.find_next
-	add	esi, 8
+  .remove_it:
+	push	[esi + tcp_out_queue_entry.data_ptr]
-	jmp	.next_resendq
+	mov	[esi + tcp_out_queue_entry.data_ptr], 0
+	dec	[TCP_OUT_QUEUE]
-  .exit:
+	call	kernel_free
-	ret
+	jmp	.find_next
+;-----------------------------------------------------------------
-;-----------------------------------------------------------------
+;
-;
-; TCP_Handler:
+; TCP_add_to_queue:
+;
+;  Queue a TCP packet for sending
 ;
-;  Called by IPv4_handler,
+;  IN:  [esp] pointer to buffer
+;       [esp + 4] size of buffer
-;  this procedure will inject the tcp data diagrams in the application sockets.
+;       ebx = driver struct
+;       esi = sender proc
-;
-;  IN:  Pointer to buffer in [esp]
-;       size of buffer in [esp+4]
-;       pointer to device struct in ebx
+;       edx = acknum
-;       TCP Packet size in ecx
+;  OUT: /
+;
+;-----------------------------------------------------------------
+align 4
-;       pointer to TCP Packet data in edx
+TCP_add_to_queue:
+	cmp	[TCP_OUT_QUEUE], TCP_QUEUE_SIZE
+	jge	.full
-;       SourceAddres in esi
+	mov	ecx, TCP_QUEUE_SIZE
-;  OUT: /
+	mov	eax, TCP_OUT_QUEUE+4
+  .loop:
+	cmp	[eax + tcp_out_queue_entry.data_ptr], 0
+	je	.found_it
-;
+	add	eax, tcp_out_queue_entry.size
-;-----------------------------------------------------------------
+	loop	.loop
-TCP_Handler :
   .full:			; silently discard the packet
-       DEBUGF 1,"TCP_Handler\n"
+	call	kernel_free
+	add	esp, 4
 	jmp .exit ;;;;
+	ret
-	; Look for a socket where
-	; IP Packet TCP Destination Port = local Port
+  .found_it:			; eax point to empty queue entry
-	; 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
+	pop	[eax + tcp_out_queue_entry.data_ptr]
-	mov	ax, [edx + 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
+	pop	[eax + tcp_out_queue_entry.data_size]
-;        DEBUGF  1, "K : tcp_rx - 1.addr: %x - %x\n", [edx + IP_Packet.SourceAddress], [ebx + SOCKET.RemoteIP]
-	mov	eax, esi ;[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
+	mov	[eax + tcp_out_queue_entry.ttl], 1			; send immediately
-;        DEBUGF  1, "K : tcp_rx - 1.sport: %x - %x\n", [edx + 20 + TCP_Packet.SourcePort]:4, [ebx + SOCKET.RemotePort]:4
-	mov	ax, [edx + 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:
+	mov	[eax + tcp_out_queue_entry.retries], TCP_RETRIES
+	mov	[eax + tcp_out_queue_entry.owner], ebx
+	mov	[eax + tcp_out_queue_entry.sendproc], esi
+	mov	[eax + tcp_out_queue_entry.ack_num], edx
-	; If we got here, there was no match
-	; Look for a socket where
+	ret
+;-----------------------------------------------------------------
+;
-	; IP Packet TCP Destination Port = local Port
-	; IP Packet SA = Remote IP
-	; socket remote Port = 0
+; TCP_handler:
+;
+;  Called by IPv4_handler,
+;  this procedure will inject the tcp data diagrams in the application sockets.
+;
+;  IN:  Pointer to buffer in [esp]
-	mov	ebx, net_sockets
+;       size of buffer in [esp+4]
+;       pointer to device struct in ebx
+;       TCP Packet size in ecx
+;       pointer to TCP Packet data in edx
-  .next_socket.2:
+;       SourceAddres in esi
-	mov	ebx, [ebx + SOCKET.NextPtr]
+;  OUT: /
+;
-	or	ebx, ebx
+;-----------------------------------------------------------------
-	jz	.next_socket.2.exit
+align 4
+TCP_handler :
-;        DEBUGF  1, "K : tcp_rx - 2.dport: %x - %x\n", [edx + 20 + TCP_Packet.DestinationPort]:4, [ebx + SOCKET.LocalPort]:4
+       DEBUGF 1,"TCP_Handler\n"
+	; IP Packet TCP Destination Port = local Port
+	; IP Packet SA = Remote IP  OR = 0
+	; IP Packet TCP Source Port = remote Port  OR = 0
+	mov	ebx, net_sockets
+  .socket_loop:
+	mov	ebx, [ebx + SOCKET_head.NextPtr]
-	mov	ax, [edx + TCP_Packet.DestinationPort]	; get the dest. port from the TCP hdr
+	or	ebx, ebx
-	cmp	[ebx + SOCKET.LocalPort], ax		; compare with socket's local port
+	jz	.dump
+	mov	ax, [edx + TCP_Packet.DestinationPort]
+	cmp	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.LocalPort], ax
-	jne	.next_socket.2				; different - try next socket
+	jne	.socket_loop
+	mov	eax, [ebx + SOCKET_head.end + IPv4_SOCKET.RemoteIP]
-;        DEBUGF  1, "K : tcp_rx - 2.addr: %x - %x\n", [edx + IP_Packet.SourceAddress], [ebx + SOCKET.RemoteIP]
+	cmp	eax, esi
+	je	@f
+	test	eax, eax
+	jne	.socket_loop
+       @@:
+	mov	ax, [ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.RemotePort]
-;        mov     eax, esi ;[edx + IP_Packet.SourceAddress]    ; get the source IP Addr from the IP hdr
+	cmp	[edx + TCP_Packet.SourcePort] , ax
-	cmp	[ebx + SOCKET.RemoteIP], esi		; compare with socket's remote IP
+	je	.change_state
-	jne	.next_socket.2				; different - try next socket
+	test	ax, ax
+	jne	.socket_loop
 ;        DEBUGF  1, "K : tcp_rx - 2.sport: 0000 - %x\n", [ebx + SOCKET.RemotePort]:4
+  .change_state:
+	push	ebx
 	lea	ebx, [ebx + SOCKET_head.lock]
-	cmp	[ebx + SOCKET.RemotePort], 0		; only match a remote socket of 0
+	call	wait_mutex
-	jne	.next_socket.2				; different - try next socket
+	pop	ebx
-	; We have a complete match - use this socket
+;----------------------------------
-	jmp	.change_state
+; ebx is pointer to socket
+; ecx is size of tcp packet
-  .next_socket.2.exit:
+; edx is pointer to tcp packet
-	; If we got here, there was no match
+	; as a Packet has been received, update the TCB timer
-	; Look for a socket where
+	mov	[ebx +	SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.TCBTimer], TWOMSL
 	; IP Packet TCP Destination Port = local Port
-	; socket Remote IP = 0
-	; socket remote Port = 0
-	mov	ebx, net_sockets
+	; If the received Packet has an ACK bit set, remove any Packets in the resend queue that this received Packet acknowledges
-  .next_socket.3:
-	mov	ebx, [ebx + SOCKET.NextPtr]
-	or	ebx, ebx
+	test	[edx + TCP_Packet.Flags], TH_ACK
-	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 + 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]
+	jz	.call_handler					; No ACK, so no data yet
-	cmp	[ebx + SOCKET.RemoteIP], 0		; only match a socket remote IP of 0
-	jne	.next_socket.3				; different - try next socket
+	mov	eax, [edx + TCP_Packet.SequenceNumber]		; Calculate sequencenumber in eax
+	bswap	eax						;
+	add	eax, ecx					;
+	cmp	[TCP_OUT_QUEUE], 0
-;        DEBUGF  1, "K : tcp_rx - 3.sport: 0000 - %x\n", [ebx + SOCKET.RemotePort]:4
+	je	.call_handler
+	push	ecx
+	mov	ecx, TCP_QUEUE_SIZE
-	cmp	[ebx + SOCKET.RemotePort], 0		; only match a remote socket of 0
+	mov	esi, TCP_OUT_QUEUE+4
-	jne	.next_socket.3				; different - try next socket
+  .loop:
+	cmp	[esi + tcp_out_queue_entry.data_ptr], 0
+	jne	.maybe_next
+	cmp	[esi + tcp_out_queue_entry.ack_num], eax
-	; We have a complete match - use this socket
+	jg	.maybe_next
-	jmp	.change_state
-  .next_socket.3.exit:
-	; If we got here, we need to reject the Packet
+	push	[esi + tcp_out_queue_entry.data_ptr]
-	DEBUGF	1, "K : tcp_rx - dumped\n"
+	mov	[esi + tcp_out_queue_entry.data_ptr], 0
+	dec	[TCP_OUT_QUEUE]
-;        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
+	call	kernel_free
-;        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:
-	call	kernel_free
-	add	esp, 4 ; pop (balance stack)
-ret
-;-----------------------------------------------------------------
-;
-; IN: eax = dest ip
-;     ebx = source ip
-;     ecx = data length
-;     edx = remote port shl 16 + local port
-;     esi = data offset
-;
-;-----------------------------------------------------------------
-TCP_create_Packet:
-	DEBUGF 1,"Create TCP Packet\n"
-;***************************************************************************
-;   Function
-;      buildTCPPacket
+  .maybe_next:
-;
+	add	esi, tcp_out_queue_entry.size
-;   Description
+	loop	.loop
+	pop	ecx
-;       builds an IP Packet with TCP data fully populated for transmission
+  .call_handler:
-;       You may destroy any and all registers
+	; Call handler for given TCB state
-;          TCP control flags specified in bl
+	mov	eax, [ebx +  SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.TCBState]
-;          This TCB is in [sktAddr]
+	cmp	eax, TCB_LISTEN
-;          User data pointed to by esi
-;       Data length in ecx
-;          Transmit buffer number in eax
-;
-;***************************************************************************
-	push	ecx			   ; Save data length
-	add	ecx, UDP_Packet.Data
-	mov	di , IP_PROTO_UDP
-;       dx  = fragment id
-	call	IPv4_create_Packet				; TODO: figure out a way to choose between IPv4 and IPv6
-	cmp	edi, -1
-	je	.exit
-	mov	[edi + TCP_Packet.Flags], bl		   ; TCP flags
-;        mov     ebx, [sockAddr];---------------------------------------------------------- eof
-	; 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
+	jb	.exit
-;        mov     [edx + IP_Packet.Identification], 0
+	cmp	eax, TCB_CLOSED
+	ja	.exit
+	shl	eax, 2
+	add	eax, TCBStateHandler - 4
+	push	.exit
+	jmp	eax
+  .exit:
+	mov	[ebx + SOCKET_head.lock], 0
+  .dump:
+	DEBUGF 1,"Dumping TCP packet\n"
-;        mov     [edx + IP_Packet.FlagsAndFragmentOffset], 0x0040
+	call	kernel_free
+	add	esp, 4 ; pop (balance stack)
+	ret
-;        mov     [edx + IP_Packet.TimeToLive], 0x20
+;-----------------------------------------------------------------
+;
+; TCP_socket_send
-;        mov     [edx + IP_Packet.Protocol], PROTOCOL_TCP
+;
+; IN: eax = socket pointer
+;     ecx = number of bytes to send
+;     esi = pointer to data
+;
-	; 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
+align 4
-;        add     ebx, 20
+TCP_socket_send:
-;        mov     [pseudoHeader + 10], bh
-;        mov     [pseudoHeader + 11], bl
-;        mov     eax, pseudoHeader
+	DEBUGF 1,"Creating TCP Packet\n"
-;        mov     [checkAdd1], eax
-;        mov     word[checkSize1], 12
+	mov	di , IP_PROTO_TCP
-;        mov     eax, edx
-;        add     eax, 20
-;        mov     [checkAdd2], eax
+; Create an IPv4 Packet of the correct size
-;        mov     eax, ebx
-;        mov     [checkSize2], ax
+	push	eax
-;
-;        call    checksum
+	mov	ebx, [eax + SOCKET_head.end + IPv4_SOCKET.LocalIP]
-	; store it in the TCP checksum ( in the correct order! )
-;        mov     ax, [checkResult]
-;        rol     ax, 8
-;        mov     [edx + 20 + TCP_Packet.Checksum], ax
+	mov	eax, [eax + SOCKET_head.end + IPv4_SOCKET.RemoteIP]
-	; Fill in the IP header checksum
-;    movzx   eax, byte [edx + IP_Packet.VersionAndIHL]  ; Calculate Header length by using IHL field
+; meanwhile, create the pseudoheader in stack,
+; (now that we still have all the variables that are needed.)
-;    and     eax, 0x0000000F  ;
+	push	cx
-;    shl     eax, 2           ;
+	push	di
-;
-	stdcall checksum_jb, edx, eax  ; buf_ptr, buf_size
-	rol	ax, 8
+	push	eax
-;        mov     [edx + IP_Packet.HeaderChecksum], ax
+	push	ebx
-       .exit:
-	call	kernel_free
+	push	ecx esi eax		; save some variables for later
-	add	esp, 4 ; pop (balance stack)
+	add	ecx, TCP_Packet.Data
+	call	IPv4_create_packet
-	ret
-;endp
+	cmp	edi, -1
-; Increments the 32 bit value pointed to by esi in internet order
-proc inc_inet_esi stdcall
-;        push    eax
-;        mov     eax, [esi]
-;        bswap   eax
+	je	.fail
-;        inc     eax
-;        bswap   eax
-;        mov     [esi], eax
-;        pop     eax
-;        ret
-	inc	byte[esi+0]
-	adc	byte[esi+1],0
-	adc	byte[esi+2],0
-	adc	byte[esi+3],0
-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
+	pop	esi
-endp
+; Now add the TCP header to the IPv4 packet
+	push	[esi + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.SND_NXT]
+	pop	[edi + TCP_Packet.SequenceNumber]
-iglobal
+	push	dword [esi + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.LocalPort]
-  TCBStateHandler dd \
+	pop	dword [edi + TCP_Packet.SourcePort]
-    stateTCB_LISTEN, \
-    stateTCB_SYN_SENT, \
-    stateTCB_SYN_RECEIVED, \
-    stateTCB_ESTABLISHED, \
+	push	[esi + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.SND_NXT]
+	pop	[edi + TCP_Packet.AckNumber]
+	mov	al, [eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.flags]
+	mov	[edi + TCP_Packet.Flags], al
+	mov	[edi + TCP_Packet.Window], 0x0005	   ; 1280 bytes               ;;; TODO: read RFC !
+	mov	[edi + TCP_Packet.UrgentPointer], 0
+	mov	[edi + TCP_Packet.DataOffset], 0x50
+	mov	[edi + TCP_Packet.Checksum], 0
+; Copy the data
+	mov	esi, [esp]
+	mov	ecx, [esp+4]
+	add	edi, TCP_Packet.Data
-    stateTCB_FIN_WAIT_1, \
+	shr	ecx, 1
-    stateTCB_FIN_WAIT_2, \
+	jnc	.nb
-    stateTCB_CLOSE_WAIT, \
+	movsb
+.nb:	shr	ecx, 1
+	jnc	.nw
+	movsw
-    stateTCB_CLOSING, \
+.nw:	rep movsd
     stateTCB_LAST_ACK, \
-    stateTCB_TIME_WAIT, \
+; Now, calculate the checksum for pseudoheader
-    stateTCB_CLOSED
+	xor	edx, edx
-endg
+	mov	ecx, 12
+	mov	esi, esp
 	call	checksum_1
-;***************************************************************************
+	add	esp, 12 				   ; remove the pseudoheader from stack
-;   Function
+; And that of the data
-;      tcpStateMachine
-;
+	pop	esi
-;   Description
+	pop	ecx
-;       TCP state machine
+	call	checksum_1
-;       This is a kernel function, called by tcp_rx
+; Now create the final checksum and store it in TCP header
-;
+	call	checksum_2
-;       IP buffer address given in edx
+	mov	[edi + TCP_Packet.Checksum], dx
-;          Socket/TCB address in ebx
-;
+; And now, send it!
-;       The IP buffer will be released by the caller
+	DEBUGF 1,"Sending TCP Packet to device %x\n", ebx
-;***************************************************************************
+	mov	esi, ETH_sender
-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
+	mov	edx, [edi + TCP_Packet.AckNumber]
-	; received Packet acknowledges
+	jmp	TCP_add_to_queue
-	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
+  .fail:
-	je	@f		  ; found one
+	add	esp, 12+4
-	inc	ecx
+	ret
-	add	esi, 8
 	jmp	.next_resendq
-    @@: 		  ; Can we delete this buffer?
-			  ; If yes, goto @@. No, goto .next_resendq
+;-----------------------------------------------------------------
 	; Get Packet data address
+; TCP_send_ack
 	push	ecx
-	; Now get buffer location, and copy buffer across. argh! more copying,,
+; IN: eax = socket pointer
-;        imul    edi, ecx, IPBUFFSIZE
+;      bl = flags
 ;        add     edi, resendBuffer
 ;-----------------------------------------------------------------
-	; we have dest buffer location in edi. incoming Packet in edx.
-	; Get this Packets sequence number
+align 4
-	; preserve al, ecx, esi, edx
+TCP_send_ack:
 	mov	ecx, [edi + 20 + TCP_Packet.SequenceNumber]
-	bswap	ecx
+	DEBUGF 1,"Creating TCP ACK\n"
 	movzx	ebx, word[edi + 2]
-	xchg	bl, bh
+	mov	di , IP_PROTO_TCP
-	sub	ebx, 40
+	mov	cx , TCP_Packet.Data
-	add	ecx, ebx	  ; ecx is now seq# of last byte +1, intel format
 	push	bx eax
-	; get recievd ack #, in intel format
-	mov	ebx, [edx + 20 + TCP_Packet.AckNumber]
+; Create an IPv4 Packet of the correct size
-	bswap	ebx
+	mov	ebx, [eax + SOCKET_head.end + IPv4_SOCKET.LocalIP]
 	mov	eax, [eax + SOCKET_head.end + IPv4_SOCKET.RemoteIP]
-	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
+	call	IPv4_create_packet
-    @@: 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
+	cmp	edi, -1
 	je	.fail
-	stdcall [TCBStateHandler + (eax - 1) * 4], [sockAddr]
+; Fill in the TCP header
+	pop	esi
   .exit:
-	ret
+	push	[esi + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.SND_NXT]
-endp
+	pop	[edi + TCP_Packet.SequenceNumber]
 	push	dword [esi + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.LocalPort]
+	pop	dword [edi + TCP_Packet.SourcePort]
-proc stateTCB_LISTEN stdcall, sockAddr:DWORD
+	push	[esi + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.SND_NXT]
-	; In this case, we are expecting a SYN Packet
+	pop	[edi + TCP_Packet.AckNumber]
-	; For now, if the Packet is a SYN, process it, and send a response
-	; If not, ignore it
+	pop	cx
 	mov	[edi + TCP_Packet.Flags], cl
-	; Look at control flags
+	mov	[edi + TCP_Packet.Window], 0x0005	   ; 1280 bytes
-	test	[edx + 20 + TCP_Packet.Flags], TH_SYN
+	mov	[edi + TCP_Packet.UrgentPointer], 0
-	jz	.exit
+	mov	[edi + TCP_Packet.DataOffset], 0x50
-	; We have a SYN. update the socket with this IP Packets details,
+	push	eax edx
 	; And send a response
+	push	word TCP_Packet.Data shl 8
+	push	IP_PROTO_TCP
-;        mov     eax, [edx + IP_Packet.SourceAddress]
+	push	[esi + SOCKET_head.end + SOCKET_head.end + IPv4_SOCKET.RemoteIP]
- ;       mov     [ebx + SOCKET.RemoteIP], eax
+	push	[esi + SOCKET_head.end + SOCKET_head.end + IPv4_SOCKET.LocalIP]
 ;        mov     ax, [edx + 20 + TCP_Packet.SourcePort]
-;        mov     [ebx + SOCKET.RemotePort], ax
+; Now, calculate the checksum for pseudoheader
-;        mov     eax, [edx + 20 + TCP_Packet.SequenceNumber]
+	xor	edx, edx
-;        mov     [ebx + SOCKET.IRS], eax
+	mov	ecx, 12
-;        mov     [ebx + SOCKET.RCV_NXT], eax
+	mov	esi, esp
-;        lea     esi, [ebx + SOCKET.RCV_NXT]
+	call	checksum_1
-;        call    inc_inet_esi ; RCV.NXT
-;        mov     eax, [ebx + SOCKET.ISS]
-;        mov     [ebx + SOCKET.SND_NXT], eax
-;
-	; Now construct the response, and queue for sending by IP
-;        mov     eax, EMPTY_QUEUE
-;        call    dequeue
-;        cmp     ax, NO_BUFFER
- ;       je      .exit
-	push	eax
-	mov	bl, TH_SYN + TH_ACK
-	xor	ecx, ecx
-	xor	esi, esi
-;        stdcall build_tcp_Packet, [sockAddr]
-;        mov     eax, NET1OUT_QUEUE
-;;;        mov     edx, [stack_ip]
-	mov	ecx, [sockAddr]
-	cmp	edx, [ecx + SOCKET.RemoteIP]
-	jne	.not_local
-;        mov     eax, IPIN_QUEUE
-  .not_local:
-	; Send it.
-	pop	ebx
+	add	esp, 12 				   ; remove the pseudoheader from stack
-;;;        call    queue
-	mov	esi, [sockAddr]
-	mov	[esi + SOCKET.TCBState], TCB_SYN_RECEIVED
-	; increment SND.NXT in socket
-	add	esi, SOCKET.SND_NXT
+; Now create the final checksum and store it in TCP header
-	call	inc_inet_esi
+	call	checksum_2
+	mov	[edi + TCP_Packet.Checksum], dx
   .exit:
-	ret
-endp
+; And now, send it!
 	DEBUGF 1,"Sending TCP Packet to device %x\n", ebx
 	mov	esi, ETH_sender
-proc stateTCB_SYN_SENT stdcall, sockAddr:DWORD
+	mov	edx, [edi + TCP_Packet.AckNumber]
-	; We are awaiting an ACK to our SYN, with a SYM
+	jmp	TCP_add_to_queue
 	; Look at control flags - expecting an ACK
   .fail:
-	mov	al, [edx + 20 + TCP_Packet.Flags]
+	add	esp, 12+4
-	and	al, TH_SYN + TH_ACK
+	ret
 	cmp	al, TH_SYN + TH_ACK
 	je	.syn_ack
 	test	al, TH_SYN
 	jz	.exit
 align 4
-	mov	[ebx + SOCKET.TCBState], TCB_SYN_RECEIVED
+stateTCB_LISTEN:
-	push	TH_SYN + TH_ACK
+	; In this case, we are expecting a SYN Packet
-	jmp	.send
+	; For now, if the Packet is a SYN, process it, and send a response
 	; If not, ignore it
   .syn_ack:
-	mov	[ebx + SOCKET.TCBState], TCB_ESTABLISHED
+	; Look at control flags
-	push	TH_ACK
+	test	[edx + TCP_Packet.Flags], TH_SYN
-  .send:
-	; Store the recv.nxt field
-	mov	eax, [edx + 20 + TCP_Packet.SequenceNumber]
+	jz	.exit
-	; Update our recv.nxt field
-	mov	[ebx + SOCKET.RCV_NXT], eax
+	; We have a SYN. update the socket with this IP Packets details,
-	lea	esi, [ebx + SOCKET.RCV_NXT]
+	; And send a response
 	call	inc_inet_esi
 	mov	[ebx + SOCKET_head.end + IPv4_SOCKET.RemoteIP], esi ; IP source address
-	; Send an ACK
+	mov	ax, [edx + TCP_Packet.SourcePort]
-	; 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
+	mov	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.RemotePort], ax
-	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]
+	mov	eax, [edx + TCP_Packet.SequenceNumber]
-  ;      jne     .not_local
-   ;     mov     eax, IPIN_QUEUE
+	mov	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.IRS], eax
-  .not_local:
-	; Send it.
-	pop	ebx
-;;;        call    queue
-  .exit:
-	ret
-endp
-proc stateTCB_SYN_RECEIVED stdcall, sockAddr:DWORD
-	; In this case, we are expecting an ACK Packet
-	; For now, if the Packet is an ACK, process it,
-	; If not, ignore it
-	test	[edx + 20 + TCP_Packet.Flags], TH_RST
-	jz	.check_ack
-	push	[ebx + SOCKET.OrigRemotePort] [ebx + SOCKET.OrigRemoteIP]
-	pop	[ebx + SOCKET.RemoteIP] [ebx + SOCKET.RemotePort]
-	mov	[ebx + SOCKET.TCBState], TCB_LISTEN
-	jmp	.exit
-  .check_ack:
-	; Look at control flags - expecting an ACK
-	test	[edx + 20 + TCP_Packet.Flags], TH_ACK
+	mov	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.RCV_NXT], eax
-	jz	.exit
+	lea	esi, [ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.RCV_NXT]
 	inc_INET esi ; RCV.NXT
-	mov	[ebx + SOCKET.TCBState], TCB_ESTABLISHED
-  .exit:
-	ret
-endp
-proc stateTCB_ESTABLISHED stdcall, sockAddr:DWORD
-	; Here we are expecting data, or a request to close
+	mov	eax, [ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.ISS]
-	; OR both...
+	mov	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.SND_NXT], eax
-	; Did we receive a FIN or RST?
-	test	[edx + 20 + TCP_Packet.Flags], TH_FIN
-	jz	.check_ack
-	; It was a fin or reset.
-	; Remove resend entries from the queue  - I dont want to send any more data
-	pushad
-	; get skt #
-	stdcall net_socket_addr_to_num, ebx
-	mov	esi, resendQ
-	mov	ecx, 0
   .next_resendq:
-;        cmp     ecx, NUMRESENDENTRIES
+	; Now construct the response
-;        je      .last_resendq       ; None left
-;        cmp     [esi + 4], eax
-;        je      @f                  ; found one
-;        inc     ecx
-;        add     esi, 8
-;        jmp     .next_resendq
+	mov	bl, TH_SYN + TH_ACK
+	call	TCP_send_ack
-    @@: mov	dword[esi + 4], 0
-	inc	ecx
+	mov	[ebx +	SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.TCBState], TCB_SYN_RECEIVED
-	add	esi, 8
-	jmp	.next_resendq
+	; increment SND.NXT in socket
 	lea	esi, [ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.SND_NXT]
-  .last_resendq:
+	inc_INET esi
 	popad
+  .exit:
-    @@: ; Send an ACK to that fin, and enter closewait state
+	ret
 	mov	[ebx + SOCKET.TCBState], TCB_CLOSE_WAIT
-	lea	esi, [ebx + SOCKET.RCV_NXT]
+align 4
-	mov	eax, [esi]		; save original
+stateTCB_SYN_SENT:
-	call	inc_inet_esi
-	;; jmp    ste_ack - NO, there may be data
+	; We are awaiting an ACK to our SYN, with a SYM
+	; Look at control flags - expecting an ACK
   .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	al, [edx + TCP_Packet.Flags]
-	mov	cx, [edx + 20 + TCP_Packet.Window]
+	and	al, TH_SYN + TH_ACK
-	xchg	cl, ch
-	cmp	cx, 1024
-	ja	@f
-	mov	[ebx + SOCKET.wndsizeTimer], 1
-    @@: ; OK, here is the deal
-	; My recv.nct field holds the seq of the expected next rec byte
-	; if the recevied sequence number is not equal to this, do not
-	; increment the recv.nxt field, do not copy data - just send a
-	; repeat ack.
-	; recv.nxt is in dword [edx+24], in inet format
-	; recv seq is in [sktAddr]+56, in inet format
-	; just do a comparision
+	cmp	al, TH_SYN + TH_ACK
-	mov	ecx, [ebx + SOCKET.RCV_NXT]
+	je	.syn_ack
-	cmp	[ebx + SOCKET.TCBState], TCB_CLOSE_WAIT
+	test	al, TH_SYN
-	jne	@f
+	jz	.exit
-	mov	ecx, eax
 	mov	[ebx +	SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.TCBState], TCB_SYN_RECEIVED
-    @@: cmp	ecx, [edx + 20 + TCP_Packet.SequenceNumber]
+	push	TH_SYN + TH_ACK
-	jne	.ack
+	jmp	.send
+  .syn_ack:
-	; Read the data bytes, store in socket buffer
+	mov	[ebx +	SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.TCBState], TCB_ESTABLISHED
-;        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
+	push	TH_ACK
-	jmp	.exit
-  .data:
-	push	ebx
-	add	ebx, SOCKET.lock
-	call	wait_mutex
-	pop	ebx
-	push	ecx
-	push	[ebx + SOCKET.PID]	; get socket owner PID
-	mov	eax, [ebx + SOCKET.rxDataCount]
-	add	eax, ecx
-	cmp	eax, SOCKETBUFFSIZE - SOCKETHEADERSIZE
-	ja	.overflow
-	mov	[ebx + SOCKET.rxDataCount], eax      ; increment the count of bytes in buffer
+  .send:
 	; Store the recv.nxt field
-	; point to the location to store the data
+	mov	eax, [edx + TCP_Packet.SequenceNumber]
-	lea	edi, [ebx + eax + SOCKETHEADERSIZE]
+	; Update our recv.nxt field
-	sub	edi, ecx
+	mov	[ebx +	SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.RCV_NXT], eax
 	lea	esi, [ebx +  SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.RCV_NXT]
-	add	edx, 40        ; edx now points to the data
+	inc_INET esi
-	mov	esi, edx
+	; Send an ACK
+	pop	ebx
-	cld
+	call	TCP_send_ack
-	rep	movsb	       ; copy the data across
-	mov	[ebx + SOCKET.lock], 0	; release mutex
+  .exit:
+	ret
 	; flag an event to the application
 	pop	eax
-	mov	ecx, 1
-	mov	esi, TASK_DATA + TASKDATA.pid
+align 4
 stateTCB_SYN_RECEIVED:
-  .next_pid:
+	; In this case, we are expecting an ACK Packet
-	cmp	[esi], eax
+	; For now, if the Packet is an ACK, process it,
-	je	.found_pid
+	; If not, ignore it
 	inc	ecx
-	add	esi, 0x20
+	test	[edx + TCP_Packet.Flags], TH_RST
-	cmp	ecx, [TASK_COUNT]
+	jz	.check_ack
-	jbe	.next_pid
-  .found_pid:
-	shl	ecx, 8
-	or	[ecx + SLOT_BASE + APPDATA.event_mask], EVENT_NETWORK ; stack event
-	pop	ecx
+	push	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.OrigRemotePort]
 	pop	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.RemotePort]
-	; 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]
+	push	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.OrigRemoteIP]
-;        mov     eax, NET1OUT_QUEUE
-;;;        mov     edx, [stack_ip]
-;        mov     ecx, [sockAddr]
- ;       cmp     edx, [ecx + SOCKET.RemoteIP]
- ;       jne     .not_local
-;        mov     eax, IPIN_QUEUE
+	pop	[ebx + SOCKET_head.end + IPv4_SOCKET.RemoteIP]
-  .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
-;; [53.7] Send data through STREAM socket
-;
-; @param EBX is socket number
-; @param ECX is application data size (number of bytes to send)
-; @param EDX is pointer to application data buffer
-; @return 0 (sent successfully) or -1 (error) in EAX
-;;
-;proc socket_write_tcp stdcall
-;local sockAddr dd ?
-;        DEBUGF  1, "socket_write_tcp(0x%x)\n", ebx
-	stdcall net_socket_num_to_addr, ebx
-	or	eax, eax
-	jz	.error
-	mov	ebx, eax
-;        mov     [sockAddr], ebx
-	; If the sockets window timer is nonzero, do not queue Packet
-	cmp	[ebx + SOCKET.wndsizeTimer], 0
-	jne	.error
-;        mov     eax, EMPTY_QUEUE
-;        call    dequeue
-;        cmp     ax, NO_BUFFER
- ;       je      .error
-	push	eax
-	; Get the address of the callers data
-	mov	edi, [TASK_BASE]
-	add	edi, TASKDATA.mem_start
-	add	edx, [edi]
-	mov	esi, edx
-	pop	eax
-	push	eax
-	push	ecx
-	mov	bl, TH_ACK

Subversion Repositories Kolibri OS

(root)/kernel/branches/net/network/tcp.inc – Rev 1206 → 1249