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

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;                                                                 ;;
-;; Copyright (C) KolibriOS team 2004-2009. All rights reserved.    ;;
+;; Copyright (C) KolibriOS team 2004-2010. All rights reserved.    ;;
 ;; Distributed under terms of the GNU General Public License       ;;
 ;;                                                                 ;;
 ;;  TCP.INC                                                        ;;
 ;;                                                                 ;;
 ;;  Part of the tcp/ip network stack for KolibriOS                 ;;
 ;;                                                                 ;;
-;;    Written by hidnplayr@kolibrios.org                           ;;
+;;   Written by hidnplayr@kolibrios.org                            ;;
+;;                                                                 ;;
-;;    Inspired by the TCP code of Mike Hibbit for MenuetOS         ;;
+;;    Based on the code of 4.4BSD                                  ;;
 ;;                                                                 ;;
 ;;          GNU GENERAL PUBLIC LICENSE                             ;;
 ;;             Version 2, June 1991                                ;;
 ;;                                                                 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+$Revision: 1514 $
+; Socket states
+TCB_CLOSED		equ 0
+TCB_LISTEN		equ 1
+TCB_SYN_SENT		equ 2
+TCB_SYN_RECEIVED	equ 3
+TCB_ESTABLISHED 	equ 4
+TCB_CLOSE_WAIT		equ 5
+TCB_FIN_WAIT_1		equ 6
+TCB_CLOSING		equ 7
+TCB_LAST_ACK		equ 8
+TCB_FIN_WAIT_2		equ 9
+TCB_TIMED_WAIT		equ 10
+; Socket Flags
+TF_ACKNOW		equ 1 shl 0	; ack peer immediately
+TF_DELACK		equ 1 shl 1	; ack, but try to delay it
+TF_NODELAY		equ 1 shl 2	; don't delay packets to coalesce
+TF_NOOPT		equ 1 shl 3	; don't use tcp options
-$Revision: 1473 $
+TF_SENTFIN		equ 1 shl 4	; have sent FIN
+TF_REQ_SCALE		equ 1 shl 5	; have/will request window scaling
+TF_RCVD_SCALE		equ 1 shl 6	; other side has requested scaling
-TCP_RETRIES		equ 5		; Number of times to resend a Packet
+TF_REQ_TSTMP		equ 1 shl 7	; have/will request timestamps
+TF_RCVD_TSTMP		equ 1 shl 8	; a timestamp was received in SYN
+TF_SACK_PERMIT		equ 1 shl 9	; other side said I could SACK
+; Segment flags
+TH_FIN			equ 1 shl 0
-TCP_PACKET_TTL		equ 50		; resend if not replied to in 1/100 s
+TH_SYN			equ 1 shl 1
+TH_RST			equ 1 shl 2
+TH_PUSH 		equ 1 shl 3
-TCP_SOCKET_TTL		equ 10		; # of secs to wait before closing socket
+TH_ACK			equ 1 shl 4
+TH_URG			equ 1 shl 5
+; Segment header options
+TCP_OPT_EOL		equ 0		; End of option list.
+TCP_OPT_NOP		equ 1		; No-Operation.
-TCP_QUEUE_SIZE		equ 16
+TCP_OPT_MAXSEG		equ 2		; Maximum Segment Size.
-TCP_MAX_ACKS		equ 16
+TCP_OPT_WINDOW		equ 3		; window scale
 TCP_OPT_TIMESTAMP	equ 8
-struct	TCP_Packet
+struct	TCP_segment
 	.SourcePort		dw ?
 	.DestinationPort	dw ?
 	.SequenceNumber 	dd ?
 	.AckNumber		dd ?
 	.DataOffset		db ?	; DataOffset[0-3 bits] and Reserved[4-7]
 	.Flags			db ?	; Reserved[0-1 bits]|URG|ACK|PSH|RST|SYN|FIN
-	.Window 		dw ?
-	.Checksum		dw ?
-	.UrgentPointer		dw ?
+	.Window 		dw ?
-;        .Options                rb 3
+	.Checksum		dw ?
-;        .Padding                db ?
+	.UrgentPointer		dw ?
-	.Data:
+	.Data:				; ..or options
 ends
 struct	tcp_in_queue_entry
 	.data_ptr	dd ?
 	.data_size	dd ?
-	.offset 	dd ?	; TODO: replace this in code by absolute address isntead of relative offset
+	.offset 	dd ?
 	.size:
 ends
-struct	tcp_out_queue_entry
-	.data_ptr	dd ?
-	.data_size	dd ?
-	.ttl		dd ?
 	.retries	dd ?
-	.owner		dd ?
+struct	tcp_out_queue_entry
-	.sendproc	dd ?
+	.data_ptr	dd ?
-	.seq_num	dd ?
+	.data_size	dd ?
-	.socket 	dd ?
 	.size:
-ends
-align 4
+ends
-uglobal
-	TCP_PACKETS_TX		rd  MAX_IP
-	TCP_PACKETS_RX		rd  MAX_IP
-	TCP_IN_QUEUE		rd  (tcp_in_queue_entry.size*TCP_QUEUE_SIZE+queue.data)/4
-	TCP_OUT_QUEUE		dd  ?, ?
-				rd  (tcp_out_queue_entry.size*TCP_QUEUE_SIZE)/4
-	TCP_ACKS		dd  ?
+align 4
-	TCP_ACK_LIST		rd  3*TCP_MAX_ACKS
-endg
-align 4
-iglobal
-TCPstateHandler:
-  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
+uglobal
-  dd  stateTCB_CLOSING
+	TCP_segments_tx 	rd IP_MAX_INTERFACES
-  dd  stateTCB_LAST_ACK
+	TCP_segments_rx 	rd IP_MAX_INTERFACES
 ;-----------------------------------------------------------------
 align 4
 TCP_init:
 	xor	eax, eax
-	mov	edi, TCP_PACKETS_TX
+	mov	edi, TCP_segments_tx
-	mov	ecx, 2*MAX_IP
+	mov	ecx, (6*IP_MAX_INTERFACES)
-	rep	stosd
-	init_queue TCP_IN_QUEUE
-; tcp_out_queue is a special type of queue:
-; The first dword is a counter of total packets queued.
-; The remaining bytes are socket 'slots' wich use tcp_out_queue_entry data structure.
-; An empty slot is know by the fact that tcp_out_queue_entry.data_ptr (first dword of the slot) is set to 0
-; There are TCP_OUT_QUEUE_SIZE number of slots
+	rep	stosd
-	xor	eax, eax
-	mov	esi, TCP_OUT_QUEUE
 	mov	ecx, TCP_QUEUE_SIZE*tcp_out_queue_entry/4+2+2+3*TCP_MAX_ACKS
-	rep	stosd
+	mov	[TCP_sequence_num],1
 	ret
 ;-----------------------------------------------------------------
+;
+; decrease socket ttls
+;
-;  TCP_decrease_socket_ttls
+; IN: /
 ; OUT: /
-;  IN:  /
+;
-;  OUT: /
+; destroys: eax
 ;
-;-----------------------------------------------------------------
-align 4
-TCP_decrease_socket_ttls:
+;-----------------------------------------------------------------
-; scan through all the sockets, decrementing active timers
+align 4
+TCP_timer_1000ms:
+; scan through all the active TCP sockets, decrementing active timers
 	mov	ebx, net_sockets
-	cmp	[ebx + SOCKET_head.NextPtr], 0
+	mov	eax, net_sockets
-	je	.exit
+  .loop:
-  .next_socket:
-	mov	ebx, [ebx + SOCKET_head.NextPtr]
-	or	ebx, ebx
+	mov	eax, [eax + SOCKET.NextPtr]
-	jz	.exit
+  .check_only:
+	or	eax, eax
-	cmp	[ebx + SOCKET_head.Type], IP_PROTO_TCP
+	jz	.exit
-	jne	.next_socket
 	cmp	[eax + SOCKET.Type], IP_PROTO_TCP
-;        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.state]
+	jne	.loop
-	cmp	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.timer], 0
+	cmp	[eax + TCP_SOCKET.t_timer], 0
 	jne	.decrement_tcb
-	cmp	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.wndsizeTimer], 0
+  ;;;;;;      cmp     [eax + TCP_SOCKET.wndsizeTimer], 0
 	jne	.decrement_wnd
-	jmp	.next_socket
+	jmp	.loop
   .decrement_tcb:
 ; decrement it, delete socket if TCB timer = 0 & socket in timewait state
-	dec	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.timer]
+	dec	[eax + TCP_SOCKET.t_timer]
-	jnz	.next_socket
 	jnz	.loop
 	cmp	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.state], TCB_TIMED_WAIT
-	jne	.next_socket
+	cmp	[eax + TCP_SOCKET.t_state], TCB_TIMED_WAIT
-	push	[ebx + SOCKET_head.PrevPtr]
-	stdcall net_socket_free, ebx
-	pop	ebx
-	jmp	.next_socket
-  .decrement_wnd:
+	jne	.loop
-	dec	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.wndsizeTimer]
-	jmp	.next_socket
 	push	[eax + SOCKET.NextPtr]
-  .exit:
+	call	SOCKET_free
-	ret
+	pop	eax
+	jmp	.check_only
-;-----------------------------------------------------------------
-;
+  .decrement_wnd:
-; TCP_send_queued:
-;
-;  Decreases 'ttl' of tcp packets queued.
-;  if 'ttl' reaches 0, resend the packet and decrease 'retries'
-;  if 'retries' reaches zero, remove the queued packet
-;
-;  IN:  /
-;  OUT: /
-;
-;-----------------------------------------------------------------
-align 4
-TCP_send_queued:
+;;;;;;        dec     [eax + TCP_SOCKET.wndsizeTimer]
-	cmp	[TCP_OUT_QUEUE], 0
-	je	.exit
+  .exit:
-	mov	ebx, TCP_OUT_QUEUE+4
+	ret
-	call	wait_mutex
-	mov	eax, TCP_QUEUE_SIZE
-	mov	ecx, [TCP_OUT_QUEUE]
-	mov	esi, TCP_OUT_QUEUE+8
-  .loop:
-	cmp	[esi + tcp_out_queue_entry.data_ptr], 0
-	jnz	.found_one
-	add	esi, tcp_out_queue_entry.size
-	loop	.loop
-  .exit:
-	mov	[TCP_OUT_QUEUE+4], 0
-	ret
+;----------------------
-  .found_one:
-	dec	[esi + tcp_out_queue_entry.ttl]
-	jz	.send_it
+;
-	cmp	[esi + tcp_out_queue_entry.data_ptr], -1
-	jz	.is_ack
+; TCP_500ms
-  .find_next:
-	add	esi, tcp_out_queue_entry.size
-	dec	eax
-	jz	.exit
-	test	ecx, ecx
-	jnz	.loop
-	mov	[TCP_OUT_QUEUE+4], 0
-	ret
-  .send_it:
-	pusha
-	mov	ebx, [esi + tcp_out_queue_entry.owner]
-	pushd	[esi + tcp_out_queue_entry.data_size]
-	pushd	[esi + tcp_out_queue_entry.data_ptr]
-	DEBUGF 1,"Now sending TCP packet %x, size: %u, owner: %x, sendproc %x\n", [esp], [esp+4], ebx, [esi + tcp_out_queue_entry.sendproc]
-	inc	[TCP_PACKETS_TX]
-	call	[esi + tcp_out_queue_entry.sendproc]
-	add	esp, 8
-	popa
 	dec	[esi + tcp_out_queue_entry.retries]
-	jz	.remove_it
+;----------------------
+align 4
-	mov	[esi + tcp_out_queue_entry.ttl], TCP_PACKET_TTL
+TCP_500ms:
+	add	[TCP_sequence_num], 64000
+	ret
-	jmp	.find_next
+;----------------------
   .remove_it:
-	push	[esi + tcp_out_queue_entry.data_ptr]
-	mov	[esi + tcp_out_queue_entry.data_ptr], 0
-	call	kernel_free
-	dec	[TCP_OUT_QUEUE]
-	jmp	.find_next
-  .is_ack:
+; TCP_10ms
 	pusha
-	mov	eax, [esi + tcp_out_queue_entry.socket]
+;----------------------
-	mov	ebx, [esi + tcp_out_queue_entry.owner]
+align 4
-	mov	ecx, [esi + tcp_out_queue_entry.size]
+TCP_10ms:
-	call	TCP_send_ack
+	; todo: decrease timers
+	ret
+;-----------------------------------------------------------------
+;
+; TCP_input:
+;
+;  IN:  [esp] = ptr to buffer
+;       [esp+4] = buffer size
+;       ebx = ptr to device struct
+;       ecx = segment size
-	popa
+;       edx = ptr to TCP segment
+;
+;       esi = ipv4 source address
+;       edi = ipv4 dest   address
+;
+;  OUT: /
+;
+;-----------------------------------------------------------------
+align 4
+TCP_input:
+       DEBUGF  1,"TCP_input\n"
+; Offset must be greater than or equal to the size of the standard TCP header (20) and less than or equal to the TCP length.
+	movzx	eax, [edx + TCP_segment.DataOffset]
+	and	eax, 0xf0
+	shr	al , 2
+	DEBUGF	1,"data offset: %u\n", eax
+	cmp	eax, 20
+	jl	.drop
+	cmp	eax, ecx
+	jg	.drop
+;-------------------------------
+; Now, re-calculate the checksum
+	push	eax edx ebx
+	push	edi
+	push	esi
+	mov	esi, edx
+	call	TCP_checksum	; this destroys edx, ecx and esi (but not edi! :)
+	pop	ebx edx eax
+	cmp	[edx + TCP_segment.Checksum], 0
+	jnz	.drop
+	DEBUGF	1,"Checksum is correct\n"
+;-----------------------------------------------------------------------------------------
+; Check if this packet has a timestamp option (We do it here so we can process it quickly)
+	cmp	eax, 20 + 12					; Timestamp option is 12 bytes
+	jl	.no_timestamp
+	je	.is_ok
+	cmp	byte [edx + TCP_segment.Data + 12], 0		; end of option list
+	jne	.no_timestamp
-	mov	[esi + tcp_out_queue_entry.data_ptr], 0
-	dec	[TCP_OUT_QUEUE]
 	jmp	.find_next
+  .is_ok:
 	test	[edx + TCP_segment.Flags], TH_SYN		; SYN flag must not be set
 	jnz	.no_timestamp
 ;-----------------------------------------------------------------
-;
+	cmp	dword [edx + TCP_segment.Data], 0x0101080a	; Timestamp header
-; TCP_handler:
+	jne	.no_timestamp
-;
+	DEBUGF	1,"timestamp ok\n"
+	; TODO: Parse the options
-;  Called by IPv4_handler,
+	; TODO: Set a Bit in the TCP to tell all options are parsed
-;  this procedure will inject the tcp data diagrams in the application sockets.
 	ret
-;  IN:  Pointer to buffer in [esp]
-;       size of buffer in [esp+4]
+  .no_timestamp:
 ;       pointer to device struct in ebx
-;       TCP Packet size in ecx
+;-------------------------------------------
-;       pointer to TCP Packet in edx
+; Convert Big-endian values to little endian
 ;       SourceAddres (IPv4) in esi
-;  OUT: /
+	ntohld	[edx + TCP_segment.SequenceNumber]
-;
+	ntohld	[edx + TCP_segment.AckNumber]
 ;-----------------------------------------------------------------
-align 4
+	ntohlw	[edx + TCP_segment.Window]
-TCP_handler :
+	ntohlw	[edx + TCP_segment.UrgentPointer]
-       DEBUGF 1,"TCP_Handler\n"
+;------------------------------------------------------------
+; Next thing to do is find the TCB (thus, the socket pointer)
+; IP Packet TCP Destination Port = local Port
+; (IP Packet SenderAddress = Remote IP)  OR  (Remote IP = 0)
-; TODO: validate checksum
+; (IP Packet TCP Source Port = remote Port)  OR (remote Port = 0)
+	mov	ebx, net_sockets
+  .socket_loop:
+	mov	ebx, [ebx + SOCKET.NextPtr]
+	or	ebx, ebx
 	jz	.drop_with_reset
-; Find a matching socket for received packet, all following expressions must be valid:
-;
+	cmp	[ebx + SOCKET.Type], IP_PROTO_TCP
-; IP Packet TCP Destination Port = local Port
-; (IP Packet SA = Remote IP)  OR  (Remote IP = 0)
-; (IP Packet TCP Source Port = remote Port)  OR (remote Port = 0)
+	jne	.socket_loop
-	mov	ebx, net_sockets
-  .socket_loop:
+	mov	ax, [edx + TCP_segment.DestinationPort]
-	mov	ebx, [ebx + SOCKET_head.NextPtr]
-	or	ebx, ebx
-	jz	.dump
+	cmp	[ebx + TCP_SOCKET.LocalPort], ax
+	jne	.socket_loop
-	mov	ax, [edx + TCP_Packet.DestinationPort]
+	mov	eax, [ebx + IP_SOCKET.RemoteIP]
-	cmp	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.LocalPort], ax
-	jne	.socket_loop
-	mov	eax, [ebx + SOCKET_head.end + IPv4_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]
-	cmp	[edx + TCP_Packet.SourcePort] , ax
-	je	.found_socket
+	cmp	eax, esi
-	test	ax, ax
-	jnz	.socket_loop
+	je	@f
-  .found_socket:
+	test	eax, eax
-       DEBUGF 1,"Found valid socket for packet\n"
-	inc	[TCP_PACKETS_RX]
-	add	ebx, SOCKET_head.lock
+	jnz	.socket_loop
-	call	wait_mutex
-	sub	ebx, SOCKET_head.lock
-;-------------------------------
+       @@:
-; ebx is pointer to socket
-; ecx is size of tcp packet
-; edx is pointer to tcp packet
+	mov	ax, [ebx + TCP_SOCKET.RemotePort]
-; calculate header length
-	movzx	eax, [edx + TCP_Packet.DataOffset]
-	and	eax, 11110000b
-	shr	eax, 2
-       DEBUGF 1,"TCP header size: %u\n", eax
-	sub	ecx, eax
-;-------------------------------
-; ecx is size of tcp data
-; as a Packet has been received, update the TCB timer
-; If the received Packet has an ACK bit set, remove any Packets in the resend queue that this received Packet acknowledges
+	cmp	[edx + TCP_segment.SourcePort] , ax
-	test	[edx + TCP_Packet.Flags], TH_ACK
-	jz	.no_ack 				 ; No ACK, so no data yet
-; Calculate ACK number, in intel byte order
-	mov	edi, [edx + TCP_Packet.AckNumber]
-	bswap	edi
+	je	.found_socket
-	mov	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.last_ack_number], edi
+	test	ax, ax
-	DEBUGF 1,"Setting last_ack_number to %u\n", edi
-; Dequeue all acknowledged packets
-	cmp	[TCP_OUT_QUEUE], 0		; first, check if any packets are queued at all
-	je	.no_ack
+	jnz	.socket_loop
+  .found_socket:
+       DEBUGF 1,"Socket ptr: %x\n", ebx
+; ebx now contains the pointer to the socket
+;----------------------------
+; Check if socket isnt closed
+	cmp	[TCP_SOCKET.t_state], TCB_CLOSED
+	je	.drop
+;----------------
+; Lock the socket
+	add	ebx, SOCKET.lock ; TODO: figure out if we should lock now already
+	call	wait_mutex
+	sub	ebx, SOCKET.lock
+;---------------------------------------
+; unscale the window into a 32 bit value  ;;;;;;
 	push	ebx
+	movzx	eax, [edx + TCP_segment.Window]
-	mov	ebx, TCP_OUT_QUEUE+4
+	xchg	al, ah
 	call	wait_mutex
-	pop	ebx
+	test	[edx + TCP_segment.Flags], TH_SYN
-	push	ecx
+	jnz	.no_syn
-	DEBUGF 1,"Removing all queued packets with smaller ACK\n"
-	mov	ecx, TCP_QUEUE_SIZE
+	mov	cl , [ebx + TCP_SOCKET.SND_SCALE]
+	shl	eax, cl
+  .no_syn:
+;-----------------------------------
+; Is this socket a listening socket?
+; If so, create a new socket
+	test	[ebx + SOCKET.options], SO_ACCEPTCON
+	jz	.no_accept_conn
+		; TODO: create a new socket
+  .no_accept_conn:
+;----------------------------
+; Compute window scale factor
+; TODO
-	mov	esi, TCP_OUT_QUEUE+8
+;-------------------------------------
+; Reset idle timer and keepalive timer
+; TODO
+;-----------------------------------------
+; Process TCP options if not in LISTEN state
+	test	[ebx + TCP_SOCKET.t_state], TCB_LISTEN
+	jz	.dont_do_options
+	call	TCP_do_options
+  .dont_do_options:
+;-----------------------------------------------------------------------
+; Time to do some header prediction (Original Principle by Van Jacobson)
+; There are two common cases for an uni-directional data transfer.
+;
+; General rule: the packets has no control flags, is in-sequence,
+;   window width didnt change and we're not retransmitting.
+;
+; Second rules:
+;  -  If the length is 0 and the ACK moved forward, we're the sender side of the transfer.
+;      In this case we'll free the ACK'ed data and notify higher levels that we have free space in buffer
+;
+;  -  If the length is not 0 and the ACK didn't move, we're the receiver side of the transfer.
+;      If the packets are in order (data queue is empty), add the data to the socket buffer and request a delayed ACK
+	cmp	[TCP_SOCKET.t_state], TCB_ESTABLISHED
+	jnz	.not_uni_xfer
+	test	[TCP_segment.Flags], TH_SYN + TH_FIN + TH_RST + TH_URG
+	jnz	.not_uni_xfer
+	test	[TCP_segment.Flags], TH_ACK
+	jz	.not_uni_xfer
+	mov	eax, [edx + TCP_segment.SequenceNumber]
+	cmp	eax, [ebx + TCP_SOCKET.RCV_NXT]
+	jne	.not_uni_xfer
+	movzx	eax, [edx + TCP_segment.Window] ;;;;;
+	cmp	eax, [ebx + TCP_SOCKET.SND_WND]
+	jne	.not_uni_xfer
+	mov	eax, [ebx + TCP_SOCKET.SND_NXT]
+	cmp	eax, [ebx + TCP_SOCKET.SND_MAX]
+	jne	.not_uni_xfer
+;-------------------------------------------------------------------------------
+; If last ACK falls within this segment's sequence number, record the timestamp.
+	; TODO: check if it has a timestamp
+;---------------------------------------
+; check if we are sender in the uni-xfer
+; If the following 4 conditions are all true, this segment is a pure ACK.
+;
+; - The segment contains no data (ti_len is 0).
+	movzx	eax, [edx + TCP_segment.DataOffset]
+	and	eax, 11110000b
+	shr	eax, 2
+	sub	ecx, eax
+	jnz	.not_sender
+; - The acknowledgment field in the segment (ti_ack) is greater than the largest unacknowledged sequence number (snd_una).
+;     Since this test is "greater than" and not "greater than or equal to," it is true only if some positive amount of data is acknowledged by the ACK.
+	mov	eax, [edx + TCP_segment.AckNumber]
+	cmp	eax, [ebx + TCP_SOCKET.SND_UNA]
+	jle	.not_uni_xfer
+; - The acknowledgment field in the segment (ti_ack) is less than or equal to the maximum sequence number sent (snd_max).
+;        mov     eax, [edx + TCP_segment.Ack]
+	cmp	eax, [ebx + TCP_SOCKET.SND_MAX]
+	jg	.not_uni_xfer
+; - The congestion window (snd_cwnd) is greater than or equal to the current send window (snd_wnd).
+;     This test is true only if the window is fully open, that is, the connection is not in the middle of slow start or congestion avoidance.
+	mov	eax, [ebx + TCP_SOCKET.SND_CWND]
+	cmp	eax, [ebx + TCP_SOCKET.SND_WND]
+	jl	.not_uni_xfer
+	DEBUGF	1,"Header prediction: we are sender\n"
+;---------------------------------
+; Packet is a pure ACK, process it
+; Update RTT estimators
+; Delete acknowledged bytes from send buffer
+; Stop retransmit timer
+; Awaken waiting processes
+; Generate more output
+	jmp	.drop
+;-------------------------------------------------
+; maybe we are the receiver in the uni-xfer then..
+  .not_sender:
+; The amount of data in the segment (ti_len) is greater than 0 (data count is in ecx)
+; The acknowledgment field (ti_ack) equals the largest unacknowledged sequence number. This means no data is acknowledged by this segment.
+	mov	eax, [edx + TCP_segment.AckNumber]
+	cmp	eax, [ebx + TCP_SOCKET.SND_UNA]
+	jne	.not_uni_xfer
+; The reassembly list of out-of-order segments for the connection is empty (seg_next equals tp).
+;;;;
+	jnz	.not_uni_xfer
+; There is room in the receive buffer for the data in the segment.
+;;;;
+	jnz	.not_uni_xfer
+;-------------------------------------
+; Complete processing of received data
+	DEBUGF	1,"header prediction: we are receiver\nreceiving %u bytes of data\n", ecx
+; The next expected receive sequence number (rcv_nxt) is incremented by the number of bytes of data.
+	add	[ebx + TCP_SOCKET.RCV_NXT], ecx
+; Add the data to the socket buffer
+; The receiving process is awakened (by sorwakeup).
+; The delayed-ACK flag is set and the input processing is complete.
+	jmp	.drop
   .loop:
-	cmp	[esi + tcp_out_queue_entry.data_ptr], 0
-	je	.maybe_next
-	cmp	[esi + tcp_out_queue_entry.socket], ebx
+;----------------------------------------------------
-	jne	.maybe_next
+; Header prediction failed, doing it the slow way..
-	cmp	[esi + tcp_out_queue_entry.seq_num], edi
-	jg	.maybe_next
+  .not_uni_xfer:
-	DEBUGF 1,"Removing a queued packet\n"
-	push	[esi + tcp_out_queue_entry.data_ptr]
+	DEBUGF	1,"Header prediction failed\n"
-	mov	[esi + tcp_out_queue_entry.data_ptr], 0
-	dec	[TCP_OUT_QUEUE]
-	call	kernel_free
-  .maybe_next:
+;------------------------
+; calculate header length                               ;;;;; we already calculated this before!
+	movzx	eax, [edx + TCP_segment.DataOffset]
+	and	eax, 0xf0
+	shr	eax, 2
-	add	esi, tcp_out_queue_entry.size
+; Update edx to point to data..
-	loop	.loop
+	add	edx, eax
+; ..and ecx to give data size
-	mov	[TCP_OUT_QUEUE+4], 0
+	sub	ecx, eax
-	pop	ecx
+;------------------------------
+; Calculate receive window size
+	;;;;
-; Now call the correct handler, depending on the socket state
-  .no_ack:
+;-------------------------
-	mov	eax, [ebx +  SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.state]
-	cmp	eax, TCB_LISTEN
+; TCP slow input procedure
-	jb	.dump
+	DEBUGF	1,"TCP slow input procedure\n"
-	cmp	eax, TCB_CLOSED
-	ja	.dump
-	call	dword [TCPstateHandler+eax*4-4]
-  .dump:
-	DEBUGF 1,"Dumping TCP packet\n"
-	call	kernel_free
-	add	esp, 4 ; pop (balance stack)
-	ret
-;-----------------------------------------------------------------
-;
+	cmp	[eax + TCP_SOCKET.t_state], TCB_LISTEN
-; TCP_send  (Assumes socket mutex set)
-;
-; IN: eax = socket pointer
-;      bl = flags
-;      ecx = number of bytes to send, may be set to 0  (single ACK)
-;      esi = pointer to data
-;
-;-----------------------------------------------------------------
-align 4
-TCP_send:
+	je	.LISTEN
-	DEBUGF 1,"Creating TCP packet, socket: %x, flags: %x\n",eax, bl
-	mov	di , IP_PROTO_TCP
-	add	ecx, TCP_Packet.Data
-	push	ecx bx eax esi
-; Create an IPv4 Packet of the correct size
-	mov	ebx, [eax + SOCKET_head.end + IPv4_SOCKET.LocalIP]
-	mov	eax, [eax + SOCKET_head.end + IPv4_SOCKET.RemoteIP]
-	call	IPv4_create_packet
-	cmp	edi, -1
-	je	.fail
+	cmp	[eax + TCP_SOCKET.t_state], TCB_SYN_SENT
-; If there is any data, copy it first
+	je	.SYN_SENT
-	pop	esi
-	push	edi
-	add	edi, TCP_Packet.Data
-	sub	ecx, TCP_Packet.Data
-	shr	ecx, 1
-	jnc	.nb
+;--------------------------------------------
-	movsb
-.nb:	shr	ecx, 1
-	jnc	.nw
-	movsw
-.nw:	test	ecx, ecx
-	jz	.nd
+; Protection Against Wrapped Sequence Numbers
-	rep	movsd
-.nd:
+; First, check timestamp if present
+;;;; TODO
+; Then, check if at least some bytes of data are within window
+;;;; TODO
+	jmp	.trim_then_step6
+align 4
+.LISTEN:
+	DEBUGF	1,"TCP state: listen\n"
+	test	[edx + TCP_segment.Flags], TH_RST
+	jnz	.drop
+	test	[edx + TCP_segment.Flags], TH_ACK
+	jnz	.drop_with_reset
+	test	[edx + TCP_segment.Flags], TH_SYN
+	jz	.drop
+	; TODO: check if it's a broadcast or multicast, and drop if so
+;;; 28.6
+	; create a new socket and fill in the nescessary variables
+;; Exit if backlog queue is full
+;        mov     ax, [ebx + TCP_SOCKET.backlog_cur]
+;        cmp     ax, [ebx + TCP_SOCKET.backlog]
+;        jae     .exit
+; Allocate new socket
+	call	SOCKET_alloc
+     ;;;   jz      .fail
+; Copy structure from current socket to new, (including lock!)
+; We start at PID to reserve the socket num, and the 2 pointers at beginning of socket
+	lea	esi, [edx + SOCKET.PID]
+	lea	edi, [eax + SOCKET.PID]
+	mov	ecx, (TCP_SOCKET.end - SOCKET.PID + 3)/4
+	rep	movsd
+;; Push pointer to new socket to queue
+;        movzx   ecx, [ebx + TCP_SOCKET.backlog_cur]
+;        inc     [ebx + TCP_SOCKET.backlog_cur]
+;        mov     [ebx + TCP_SOCKET.end + ecx*4], eax
+	mov	[eax + IP_SOCKET.RemoteIP], esi ; IP source address
+	mov	cx, [edx + TCP_segment.SourcePort]
+	mov	[eax + TCP_SOCKET.RemotePort], cx
+	mov	ecx, [edx + TCP_segment.SequenceNumber]
+	mov	[eax + TCP_SOCKET.IRS], ecx
+	mov	ecx, [eax + TCP_SOCKET.ISS]
+	mov	[eax + TCP_SOCKET.SND_NXT], ecx
-	pop	edi
+	jmp	.trim_then_step6
+align 4
+.SYN_SENT:
+	DEBUGF	1,"TCP state: syn_sent\n"
+	test	[edx + TCP_segment.Flags], TH_ACK
+	jz	@f
-; Fill in the TCP header
+	mov	eax, [edx + TCP_segment.AckNumber]
+	cmp	eax, [ebx + TCP_SOCKET.ISS]
-	pop	esi
-; fill in tcp sequence number
-	push	[esi + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.SND_NXT]
-	pop	[edi + TCP_Packet.SequenceNumber]
-; Fill in local and remote ports
-	push	dword [esi + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.LocalPort]
-	pop	dword [edi + TCP_Packet.SourcePort]
-; Acknumber
-	push	[esi + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.RCV_NXT]
-	pop	[edi + TCP_Packet.AckNumber]
-; Fill  in other tcp options
-	pop	cx
-	mov	[edi + TCP_Packet.Flags], cl
-	mov	[edi + TCP_Packet.Window], 0x0005	   ; 1280 bytes
-	mov	[edi + TCP_Packet.UrgentPointer], 0
-	mov	[edi + TCP_Packet.DataOffset], 0x50
+	jle	.drop_with_reset
-	mov	[edi + TCP_Packet.Checksum], 0
+	mov	eax, [edx + TCP_segment.AckNumber]
-; Get size of total packet back in ecx
+	cmp	eax, [ebx + TCP_SOCKET.SND_MAX]
-	pop	ecx
+	jg	.drop_with_reset
+       @@:
+	test	[edx + TCP_segment.Flags], TH_RST
+	jz	@f
+	test	[edx + TCP_segment.Flags], TH_ACK
+	jz	.drop
+	;tp = tcp_drop(tp, ECONNREFUSED)
+	jmp	.drop
+       @@:
+	test	[edx + TCP_segment.Flags], TH_SYN
+	jz	.drop
+; now, process received SYN in response to an active open
+	test	[edx + TCP_segment.Flags], TH_ACK
+	jz	@f
+	mov	eax, [edx + TCP_segment.AckNumber]
+	mov	[ebx + TCP_SOCKET.SND_UNA], eax
+	mov	eax, [ebx + TCP_SOCKET.SND_UNA]
+	cmp	eax, [ebx + TCP_SOCKET.SND_NXT]
+	jle	@f
+	mov	[ebx + TCP_SOCKET.SND_NXT], eax
+; TODO: turn off retransmission timer
+	mov	eax, [edx + TCP_segment.SequenceNumber]
+	mov	[ebx + TCP_SOCKET.IRS], eax
+; TODO: set socket state to connected
+	mov	[ebx + TCP_SOCKET.t_state], TCB_ESTABLISHED
+; TODO: check if we should scale the connection (567-572)
+; TODO: update RTT estimators
+       @@:
+; We have received a syn but no ACK, so we are having a simultaneous open..
+	mov	[ebx + TCP_SOCKET.t_state], TCB_SYN_RECEIVED
-; Push pointer to and size of total packet (needed for send procedure)
+;-------------------------------------
+; Common processing for receipt of SYN
+  .trimthenstep6:
+	inc	[edx + TCP_segment.SequenceNumber]
+	cmp	cx, [ebx + TCP_SOCKET.RCV_WND]
+	jle	@f
+	movzx	eax, cx
+	sub	ax, [ebx + TCP_SOCKET.RCV_WND]
+	; TODO: 592
+	mov	cx, [ebx + TCP_SOCKET.RCV_WND]
+	; TODO...
+       @@:
+	;;;;;
+	;;; jmp     .step6
+align 4
+.trim_then_step6:
+	DEBUGF	1,"Trim, then step 6\n"
+;----------------------------
+; trim any data not in window
+	mov	eax, [ebx + TCP_SOCKET.RCV_NXT]
+	sub	eax, [edx + TCP_segment.SequenceNumber]
+	test	eax, eax
+	jz	.no_drop
+	test	[edx + TCP_segment.Flags], TH_SYN
+	jz	.no_drop
+	and	[edx + TCP_segment.Flags], not (TH_SYN)
+	inc	[edx + TCP_segment.SequenceNumber]
+	cmp	[edx + TCP_segment.UrgentPointer], 1
+	jl	@f
+	dec	[edx + TCP_segment.UrgentPointer]
+	jmp	.no_drop
+       @@:
+	and	[edx + TCP_segment.Flags], not (TH_URG)
+	dec	eax
+  .no_drop:
+; eax holds number of bytes to drop
+;----------------------------------
+; Check for entire duplicate packet
+	cmp	eax, ecx
+	jge	.duplicate
+	;;; TODO: figure 28.30
+;;        inc     [TCP_segments_rx]
+;;        add     dword [TCP_bytes_rx], ecx
+;;        adc     dword [TCP_bytes_rx+4], 0
+;------------------------
+; Check for duplicate FIN
+	test	[edx + TCP_segment.Flags], TH_FIN
+	jz	@f
+	inc	ecx
+	cmp	eax, ecx
+	dec	ecx
+	jne	@f
+	mov	eax, ecx
+	and	[edx + TCP_segment.Flags], not TH_FIN
+	;;; TODO: set ACKNOW flag
+	jmp	.no_duplicate
+       @@:
+	; Handle the case when a bound socket connects to itself
+	; Allow packets with a SYN and an ACKto continue with the processing
+;-------------------------------------
+; Generate duplicate ACK if nescessary
+; This code also handles simultaneous half-open or self-connects
+	test	eax, eax
+	jnz	.drop_after_ack
+	cmp	[edx + TCP_segment.Flags], TH_ACK
+	jz	.drop_after_ack
+  .duplicate:
+;----------------------------------------
+; Update statistics for duplicate packets
+	;;; TODO
+	;;; DROP the packet ??
+  .no_duplicate:
+;-----------------------------------------------
+; Remove duplicate data and update urgent offset
+	add	[edx + TCP_segment.SequenceNumber], eax
+	;;; TODO
+	sub	[edx + TCP_segment.UrgentPointer], ax
+	jg	@f
+	and	[edx + TCP_segment.Flags], not (TH_URG)
+	mov	[edx + TCP_segment.UrgentPointer], 0
+       @@:
+;--------------------------------------------------
+; Handle data that arrives after process terminates
+	cmp	[ebx + SOCKET.PID], 0
+	jge	@f
+	cmp	[ebx + TCP_SOCKET.t_state], TCB_CLOSE_WAIT
+	jle	@f
+	test	ecx, ecx
+	jz	@f
+	;;; Close the socket
+	;;; update stats
+	jmp	.drop_with_reset
+       @@:
+;----------------------------------------
+; Remove data beyond right edge of window
+	mov	eax, [edx + TCP_segment.SequenceNumber]
+	add	eax, ecx
+	sub	eax, [ebx + TCP_SOCKET.RCV_NXT]
+	sub	ax, [ebx + TCP_SOCKET.RCV_WND]
+	; eax now holds the number of bytes to drop
+	jle	.no_excess_data
+	;;; TODO: update stats
+	cmp	eax, ecx
+	jl	.dont_drop_all
+;;; TODO 700-736
+  .dont_drop_all:
+  .no_excess_data:
+;-----------------
+; Record timestamp
+	;;; TODO 737-746
+;------------------
+; Process RST flags
+	test	[edx + TCP_segment.Flags], TH_RST
+	jz	.rst_skip
+	mov	eax, [ebx + TCP_SOCKET.t_state]
+	shl	eax, 2
+	jmp	dword [eax + .rst_sw_list]
+  .rst_sw_list:
+	dd	.rst_skip	;TCB_CLOSED
+	dd	.rst_skip	;TCB_LISTEN
+	dd	.rst_skip	;TCB_SYN_SENT
+	dd	.econnrefused	;TCB_SYN_RECEIVED
+	dd	.econnreset	;TCB_ESTABLISHED
+	dd	.econnreset	;TCB_CLOSE_WAIT
+	dd	.econnreset	;TCB_FIN_WAIT_1
+	dd	.rst_close	;TCB_CLOSING
+	dd	.rst_close	;TCB_LAST_ACK
+	dd	.econnreset	;TCB_FIN_WAIT_2
+	dd	.rst_close	;TCB_TIMED_WAIT
+  .econnrefused:
+	;;; TODO: debug info
+	jmp	.close
+  .econnreset:
+	;;; TODO: debug info
+    .close:
+	;;; update stats
+  .rst_close:
+	;;; Close the socket
+	jmp	.drop
+  .rst_skip:
+;--------------------------------------
+; handle SYN-full and ACK-less segments
+	test	[edx + TCP_segment.Flags], TH_SYN
+	jz	@f
+	;;; tcp_drop ( ECONNRESET)
+	jmp	.drop_with_reset
+	test	[edx + TCP_segment.Flags], TH_ACK
+	jz	.drop
+;----------------
+; Process the ACK
+	cmp	[ebx + TCP_SOCKET.t_state], TCB_SYN_RECEIVED
+	jg	.ack_dup
+	jl	.ack_nodup
+;        dd      .ack_nodup      ;TCB_CLOSED
+;        dd      .ack_nodup      ;TCB_LISTEN
+;        dd      .ack_nodup      ;TCB_SYN_SENT
+;        dd      .ack_syn_rcvd   ;TCB_SYN_RECEIVED
+;        dd      .ack_dup        ;TCB_ESTABLISHED
+;        dd      .ack_dup        ;TCB_CLOSE_WAIT
+;        dd      .ack_dup        ;TCB_FIN_WAIT_1
+;        dd      .ack_dup        ;TCB_CLOSING
+;        dd      .ack_dup        ;TCB_LAST_ACK
+;        dd      .ack_dup        ;TCB_FIN_WAIT_2
+;        dd      .ack_dup        ;TCB_TIMED_WAIT
+	;;;;;
+  .ack_dup:
+	;;;;
+  .ack_nodup:
+	;;;; 887
+;-------------------------------------------------
+; If the congestion window was infalted to account
+; for the other side's cached packets, retrace it
+	;;;; 888 -  902
+;------------------------------------------
+; RTT measurements and retransmission timer
+	;;;;; 903 - 926
+;-------------------------------------------
+; Open congestion window in response to ACKs
+	;;;;
+;------------------------------------------
+; Remove acknowledged data from send buffer
+	;;;; 943 - 956
+;---------------------------------------
+; Wake up process waiting on send buffer
+	;;;;;
+	mov	eax, [ebx + TCP_SOCKET.t_state]
+	shl	eax, 2
+	jmp	dword [eax + .ACK_sw_list]
+  .ACK_sw_list:
-	push	edx eax
+	dd	.step6		;TCB_CLOSED
+	dd	.step6		;TCB_LISTEN
+	dd	.step6		;TCB_SYN_SENT
+	dd	.step6		;TCB_SYN_RECEIVED
+	dd	.step6		;TCB_ESTABLISHED
+	dd	.step6		;TCB_CLOSE_WAIT
+	dd	._963		;TCB_FIN_WAIT_1
+	dd	._958		;TCB_CLOSING
+	dd	._999		;TCB_LAST_ACK
+	dd	.step6		;TCB_FIN_WAIT_2
+	dd	._1010		;TCB_TIMED_WAIT
+._963:
+	jmp	.step6
+._958:
+	jmp	.step6
+._999:
+	jmp	.step6
+._1010:
+	jmp	.step6
+align 4
+.step6:
+	DEBUGF	1,"step 6\n"
+;--------------------------
+; update window information
+	test	[edx + TCP_segment.Flags], TH_ACK
+	jz	.no_window_update
+	mov	eax, [ebx + TCP_SOCKET.SND_WL1]
+	cmp	eax, [edx + TCP_segment.SequenceNumber]
+	;;;; 1021
+;----------------------------------
+; Keep track of pure window updates
+	test	ecx, ecx
+	jz	@f
+	mov	eax, [ebx + TCP_SOCKET.SND_WL2]
+	cmp	eax, [edx + TCP_segment.AckNumber]
+	jne	@f
+	;; mov eax, tiwin
+	cmp	eax, [ebx + TCP_SOCKET.SND_WND]
+	jle	@f
+	;;; update stats
+       @@:
+	;; mov eax, incoming window
+	cmp	eax, [ebx + TCP_SOCKET.max_sndwnd]
+	jle	@f
+	mov	[ebx + TCP_SOCKET.max_sndwnd], eax
+       @@:
+	mov	[ebx + TCP_SOCKET.SND_WND], eax
+	mov	eax, [edx + TCP_segment.SequenceNumber]
+	mov	[ebx + TCP_SOCKET.SND_WL1], eax
+	mov	eax, [edx + TCP_segment.AckNumber]
+	mov	[ebx + TCP_SOCKET.SND_WL2], eax
+	;;; needoutput = 1
+  .no_window_update:
+;-----------------
+; process URG flag
+	test	[edx + TCP_segment.Flags], TH_URG
+	jz	.not_urgent
+	cmp	[edx + TCP_segment.UrgentPointer], 0
+	jz	.not_urgent
+	cmp	[ebx + TCP_SOCKET.t_state], TCB_TIMED_WAIT
+	je	.not_urgent
+; Ignore bogus urgent offsets
+	;;; 1040-1050
+	movzx	eax, [edx + TCP_segment.UrgentPointer]
+	add	eax, [ebx + SOCKET.SO_RCV.SB_CC]
+	cmp	eax, SOCKET_MAXDATA
+	jle	.not_urgent
+	mov	[edx + TCP_segment.UrgentPointer], 0
+	and	[edx + TCP_segment.Flags], not (TH_URG)
+	jmp	.do_data
+  .not_urgent:
+;--------------------------------------
+; processing of received urgent pointer
-; push socket number (for TCP_add_to_queue)
+	;;; 1051-1093
-	push	esi
+align 4
-; Now, calculate the checksum
-	xchg	cl, ch
-	pushw	cx
-	xchg	cl, ch
-	pushw	IP_PROTO_TCP shl 8
-	pushd	[edi-4] ; destination address           ; TODO: fix this, IPv4 packet could have options..
-	pushd	[edi-8] ; source address
-	xor	edx, edx
-	mov	esi, edi
-	call	checksum_1
+.do_data:
-	mov	ecx, 12
+	DEBUGF	1,"Do data:\n"
-	mov	esi, esp
+	; process the data in the segment
-	call	checksum_1
-; and store it in TCP header
-	call	checksum_2
-	mov	[edi + TCP_Packet.Checksum], dx
-	add	esp, 10 				   ; remove the pseudoheader from stack
-	DEBUGF 1,"Sending TCP Packet to device %x\n", ebx
-	mov	edx, [edi + TCP_Packet.SequenceNumber]
-	bswap	edx
-	mov	esi, [ebx + ETH_DEVICE.transmit]
-	pop	cx					   ; get the length from packet, back from pseudoheader
-	pop	edi
+	test	[edx + TCP_segment.Flags], TH_FIN
-	cmp	cx, TCP_Packet.Data shl 8		   ; if the packet has no data
-	je	.only_one				   ; send it only once
+	jz	.process_fin
+	test	[ebx + TCP_SOCKET.t_state], TCB_FIN_WAIT_1 ;;;;;
+	jge	.dont_do_data
+	DEBUGF	1,"Processing data in segment\n"
+	;;; NOW, process the data
+	jmp	.final_processing
-	and	ecx, 0x0000ffff
+  .dont_do_data:
+;---------------
+; FIN processing
+  .process_fin:
+	DEBUGF	1,"Processing FIN\n"
+	mov	eax, [ebx + TCP_SOCKET.t_state]
+	shl	eax, 2
+	jmp	dword [eax + .FIN_sw_list]
+  .FIN_sw_list:
+	dd	.no_fin 	;TCB_CLOSED
+	dd	.no_fin 	;TCB_LISTEN
+	dd	.no_fin 	;TCB_SYN_SENT
+	dd	._1131		;TCB_SYN_RECEIVED
+	dd	._1131		;TCB_ESTABLISHED
+	dd	.no_fin 	;TCB_CLOSE_WAIT
+	dd	._1139		;TCB_FIN_WAIT_1
+	dd	.no_fin 	;TCB_CLOSING
+	dd	.no_fin 	;TCB_LAST_ACK
+	dd	._1147		;TCB_FIN_WAIT_2
+	dd	._1156		;TCB_TIMED_WAIT
+  ._1131:
+  ._1139:
+  ._1147:
+  ._1156:
+  .no_fin:
+;-----------------
+; Final processing
+  .final_processing:
+	DEBUGF	1,"Final processing\n"
+	;;; if debug enabled, output packet
-	xchg	cl, ch
-	sub	cx, TCP_Packet.Data
+	;test    ;;;needoutput = 1
+	;jnz     .outputnow
+	test	[ebx + TCP_SOCKET.t_flags], TF_ACKNOW
+	jz	.ret
+  .outputnow:
+	call	TCP_output
+  .ret:
+	mov	[ebx + SOCKET.lock], 0
+	call	kernel_free
+	ret	4
+;------------------------------------------
-	add_INET (edi + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.SND_NXT)     ; todo: this should only happen when packet was queued successful
+; Generate an ACK, droping incoming segment
-	mov	ecx, TCP_RETRIES
 align 4
-	jmp	.go_for_it
+.drop_after_ack:
 	DEBUGF	1,"Drop after ACK\n"
-  .only_one:
+	test	[edx + TCP_segment.Flags], TH_RST
+	jnz	.drop
+	and	[ebx + TCP_SOCKET.t_flags], TF_ACKNOW
-	mov	ecx, 1
-  .go_for_it:
+	call	TCP_output
-	mov	[edi + SOCKET_head.lock], 0
-	jmp	TCP_queue				; At last send the packet!
-  .fail:
-	add	esp, 2+4
+	mov	[ebx + SOCKET.lock], 0
-	or	eax, -1
+	call	kernel_free
-	ret
-;-----------------------------------------------------------------
-;
-;  Queue a TCP packet for sending
-;
-;  IN:  [esp] pointer to buffer
-;       [esp + 4] size of buffer
-;       ebx = driver struct
+	ret	4
-;       edx = sequence number of this packet in intel byte order
-;       esi = sender proc
+;-------------------------------------------
-;       edi = socket number
+; Generate an RST, dropping incoming segment
-;  OUT: /
-;
+align 4
-;-----------------------------------------------------------------
-align 4
-TCP_queue:
+.drop_with_reset:
-	DEBUGF 1,"Adding packet to TCP queue, buffer: %x, size: %u, driver: %x, acknum: %u\n", [esp], [esp+4], ebx, edx
+	DEBUGF	1,"Drop with reset\n"
+	test	[edx + TCP_segment.Flags], TH_RST
+	jnz	.drop
-	cmp	[TCP_OUT_QUEUE], TCP_QUEUE_SIZE
-	jge	.full
+	;;; if its a multicast/broadcast, also drop
-	push	ebx
-	mov	ebx, TCP_OUT_QUEUE+4
+	test	[edx + TCP_segment.Flags], TH_ACK
-	call	wait_mutex
+	jnz	.respond_ack
-	pop	ebx
-	mov	ecx, TCP_QUEUE_SIZE
-	mov	eax, TCP_OUT_QUEUE+8
-  .loop:
-	cmp	[eax + tcp_out_queue_entry.data_ptr], 0
+	test	[edx + TCP_segment.Flags], TH_SYN
-	je	.found_it
+	jnz	.respond_syn
-	add	eax, tcp_out_queue_entry.size
-	loop	.loop
+	mov	[ebx + SOCKET.lock], 0
-	add	esp, 4
-  .full:			; silently discard the packet
+	call	kernel_free
-	DEBUGF 1,"TCP queue is full!\n"
+	ret	4
-	call	kernel_free
-	add	esp, 4
+  .respond_ack:
-	ret
+	;;;;
-  .found_it:			; eax points to empty queue entry
+	call	TCP_respond
+	jmp	.destroy_new_socket
-	mov	[eax + tcp_out_queue_entry.retries], TCP_RETRIES
-	pop	[eax + tcp_out_queue_entry.data_ptr]
+  .respond_syn:
-	pop	[eax + tcp_out_queue_entry.data_size]
+	;;;;
-	mov	[eax + tcp_out_queue_entry.ttl], 1			; send immediately
+	call	TCP_respond
-	mov	[eax + tcp_out_queue_entry.owner], ebx
-	mov	[eax + tcp_out_queue_entry.sendproc], esi
+	jmp	.destroy_new_socket
+;-----
+; Drop
-	mov	[eax + tcp_out_queue_entry.seq_num], edx
-	mov	[eax + tcp_out_queue_entry.socket], edi
+align 4
+.drop:
-	inc	[TCP_OUT_QUEUE]
+	DEBUGF	1,"Dropping packet\n"
-	sub	eax, TCP_OUT_QUEUE+8
+	;;;; If debugging options are enabled, output the packet somwhere
+  .destroy_new_socket:
+	;;;; kill the newly created socket
-	shr	eax, 5
-	DEBUGF 1,"Added to queue in pos %u, total queued packets: %u\n", eax, [TCP_OUT_QUEUE+8]
+	mov	[ebx + SOCKET.lock], 0
-	mov	[TCP_OUT_QUEUE+4], 0
+	call	kernel_free
-	ret
+	ret	4
-;-----------------------------------------------------------------
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;
-;  IN:  ebx = socket
 ;       ecx = ack number
-;
-;  OUT: /
-;
 ;-----------------------------------------------------------------
+;---------------------
+;
+; TCP_do_options
+;
+;-------------------
+align 4
+TCP_do_options:
+	DEBUGF	1,"TCP_do_options\n"
-align 4
+	push	eax
+	sub	eax, 20
+	jz	.no_options
-TCP_queue_ack:
+	lea	esi, [edx + TCP_segment.Data]
+;-------------------------------------------
+; Begin the loop by checking for EOL and NOP
+  .loop:
+	cmp	byte [esi], TCP_OPT_EOL 	; end of option list?
+	jz	.no_options
+	cmp	byte [esi], TCP_OPT_NOP 	; nop ?
+      ;;;  cmove   edi, 1                          ; if so, set option size to 1
+	jz	.continue			; and continue scanning
-	DEBUGF 1,"Adding ACK to TCP queue, socket: %x, acknum: %u\n", ebx, ecx
+;------------------
 ; We have an option
-	cmp	[TCP_OUT_QUEUE], TCP_QUEUE_SIZE
-	jge	.full
+	movzx	edi, byte [esi + 1]		; get the length of this option in edi
-	push	ebx ecx
+;--------------------------------------
-	mov	ebx, TCP_OUT_QUEUE+4
+; Check for Maximum segment size option
-	call	wait_mutex
 	cmp	byte [esi], TCP_OPT_MAXSEG
-	mov	ecx, TCP_QUEUE_SIZE
+	jne	.no_maxseg
-	mov	eax, TCP_OUT_QUEUE+8
   .loop:
-	cmp	[eax + tcp_out_queue_entry.data_ptr], 0
+	cmp	edi, 4	; option length
-	je	.found_it
+	jne	.continue
-	add	eax, tcp_out_queue_entry.size
-	loop	.loop
+	test	[edx + TCP_segment.Flags], TH_SYN
+	jz	.continue
-	add	esp, 8
-  .full:			; silently discard the packet
+	; Now parse the option...
-	DEBUGF 1,"TCP queue is full!\n"
-	ret
-  .found_it:			; eax points to empty queue entry
-	pop	[eax + tcp_out_queue_entry.data_size]			; ACK number
-	mov	[eax + tcp_out_queue_entry.data_ptr], -1		; ACK packet
-	pop	[eax + tcp_out_queue_entry.socket]
-	mov	[eax + tcp_out_queue_entry.retries], 1
+	jmp	.continue
-	mov	[eax + tcp_out_queue_entry.ttl], 20			; 200 ms
+  .no_maxseg:
-	inc	[TCP_OUT_QUEUE]
+;------------------------
-	sub	eax, TCP_OUT_QUEUE+8
-	shr	eax, 5
+; Check for Window option
-	DEBUGF 1,"Added to queue in pos %u, total queued packets: %u\n", eax, [TCP_OUT_QUEUE+8]
+	cmp	byte [esi], TCP_OPT_WINDOW
+	jne	.no_window
+	cmp	edi, 3 ; option length
+	jne	.continue
+	test	[edx + TCP_segment.Flags], TH_SYN
+	jz	.continue
+	; ...
+	jmp	.continue
-	mov	[TCP_OUT_QUEUE+4], 0
+  .no_window:
+;---------------------------
+; Check for Timestamp option
+	cmp	byte [esi], TCP_OPT_TIMESTAMP
+	jne	.no_timestamp
+	cmp	edi, 10 ; option length
-	ret
+	jne	.continue
-; IN: eax = socket pointer
-;     ebx = device structure
-;     ecx = ack number
-align 4
-TCP_send_ack:
-	DEBUGF 1,"Creating TCP ACK packet, socket: %x, acknum: %x\n", eax, ecx
-	push	ecx eax
-	mov	di , IP_PROTO_TCP
-	mov	ecx, TCP_Packet.Data
-; Create an IPv4 Packet of the correct size
-	mov	ebx, [eax + SOCKET_head.end + IPv4_SOCKET.LocalIP]
-	mov	eax, [eax + SOCKET_head.end + IPv4_SOCKET.RemoteIP]
-	call	IPv4_create_packet
-	cmp	edi, -1
+	; ...
-	je	.fail
-	pop	ecx
-; fill in tcp sequence number
-	push	[ecx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.SND_NXT]
-	pop	[edi + TCP_Packet.SequenceNumber]
-; Fill in local and remote ports
-	push	dword [ecx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.LocalPort]
-	pop	dword [edi + TCP_Packet.SourcePort]
-; Acknumber
-	pop	[edi + TCP_Packet.AckNumber]
-; Fill  in other tcp options
-	mov	[edi + TCP_Packet.Flags], TH_ACK
-	mov	[edi + TCP_Packet.Window], 0x0005	   ; 1280 bytes
-	mov	[edi + TCP_Packet.UrgentPointer], 0
+	jmp	.continue
-	mov	[edi + TCP_Packet.DataOffset], 0x50
-	mov	[edi + TCP_Packet.Checksum], 0
+  .no_timestamp:
-; Push pointer to and size of total packet (needed for send procedure)
+;----------------------------------
+; Future options may be placed here
-	push	edx eax esi
-; Now, calculate the checksum
-	pushw	TCP_Packet.Data shl 8
+;------------------------------
-	pushw	IP_PROTO_TCP shl 8
+; Continue scanning for options
-	pushd	[edi-4] ; destination address           ; TODO: fix this, IPv4 packet could have options..
+  .continue:
-	pushd	[edi-8] ; source address
+	add	esi, edi
+	sub	eax, edi
+	jg	.loop
-	xor	edx, edx
-	mov	ecx, 12
+  .no_options:
-	mov	esi, esp
-	call	checksum_1
+	pop	eax
-	call	checksum_2
+	ret
-	mov	[edi + TCP_Packet.Checksum], dx
-	add	esp, 12 				; remove the pseudoheader from stack
-	pop	eax
-	call	eax
+;---------------------------
-	call	kernel_free
+;
-	add	esp, 4 ; pop (balance stack)
-	ret
+; TCP_pull_out_of_band
+;
-  .fail:
+; IN:  eax =
+;      ebx = socket ptr
-	add	esp, 8
+;      edx = tcp packet ptr
+;
+; OUT: /
-	ret
+;
+;---------------------------
-;-----------------------------------------------------------------
-;
-; Remove all queued TCP packets for a specified socket
-;
-; IN: eax = socket number
-; OUT: /
-;
-; destoys esi and ecx
-;
-;-----------------------------------------------------------------
+align 4
+TCP_pull_out_of_band:
-align 4
-TCP_remove_socket:
+	DEBUGF	1,"TCP_pull_out_of_band\n"
-	cmp	[TCP_OUT_QUEUE], 0
-	je	.skip
-	mov	ebx, TCP_OUT_QUEUE+4
+	;;;; 1282-1305
-	call	wait_mutex
+	ret
-	mov	eax, TCP_QUEUE_SIZE
-	mov	ecx, [TCP_OUT_QUEUE]
-	mov	esi, TCP_OUT_QUEUE+8
-  .loop:
-	cmp	[esi + tcp_out_queue_entry.data_ptr], 0
-	jz	.maybenext
-	cmp	[esi + tcp_out_queue_entry.socket], eax
-	jnz	.maybenext
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-	push	[esi + tcp_out_queue_entry.data_ptr]
-	mov	[esi + tcp_out_queue_entry.data_ptr], 0
-	dec	[TCP_OUT_QUEUE]
-	call	kernel_free
-  .maybenext:
-	add	esi, tcp_out_queue_entry.size
-	loop	.loop
+;-----------------------------------------------------------------
+;
+; TCP_output
+;
-	mov	[TCP_OUT_QUEUE+4], 0
+; IN: eax = socket pointer
-  .skip:
+;;     esi = ptr to data
+;;     ecx = number of data bytes
+;
-	ret
+; OUT: /
+;
+;-----------------------------------------------------------------
-;---------- TCB state handlers start here
+align 4
+TCP_output:
-align 4
+	DEBUGF 1,"TCP_output, socket: %x\n", eax
-stateTCB_LISTEN:
-	DEBUGF	1,"TCBStateHandler: Listen\n"
-	test	[edx + TCP_Packet.Flags], TH_SYN	; SYN packet? => send syn+ack, open new socket and set connection to established
-	jz	.exit
-; Exit if backlog queue is full
+; We'll detect the length of the data to be transmitted, and flags to be used
-	mov	ax, [ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.backlog_cur]
-	cmp	ax, [ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.backlog]
+; If there is some data, or any critical controls to send (SYN / RST), then transmit
-	jae	.exit
-; Allocate new socket
-	push	esi edi
-	call	net_socket_alloc
-	test	eax, eax
-	jz	.fail
-; Copy structure from current socket to new, including lock
-	lea	esi, [ebx + SOCKET_head.PID]		; yes, PID must also be copied
-	lea	edi, [eax + SOCKET_head.PID]
-	mov	ecx, ((SOCKET_head.end - SOCKET_head.PID) + IPv4_SOCKET.end + TCP_SOCKET.end + 3)/4
-	rep	movsd
-	pop	edi esi
-; Push pointer to new socket to queue
-	movzx	ecx, [ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.backlog_cur]
+; Otherwise, investigate further
-	inc	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.backlog_cur]
-	mov	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.end + ecx*4], eax
+	mov	ebx, [eax + TCP_SOCKET.SND_MAX]
-	mov	[eax + SOCKET_head.end + IPv4_SOCKET.RemoteIP], esi ; IP source address
-	mov	cx, [edx + TCP_Packet.SourcePort]
-	mov	[eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.RemotePort], cx
+	cmp	ebx, [eax + TCP_SOCKET.SND_UNA]
-	mov	ecx, [edx + TCP_Packet.SequenceNumber]
-	mov	[eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.IRS], ecx
-	mov	[eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.RCV_NXT], ecx
-	lea	esi, [eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.RCV_NXT]
-	inc_INET esi ; RCV.NXT
-	mov	ecx, [eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.ISS]
-	mov	[eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.SND_NXT], ecx
-	mov	[ebx + SOCKET_head.lock], 0
-	push	eax
-; Now construct the response
-	mov	bl, TH_SYN + TH_ACK
-	xor	ecx, ecx
-	call	TCP_send
-	pop	eax
-	mov	[eax + SOCKET_head.lock], 0
-	mov	[eax +	SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.state], TCB_SYN_RECEIVED
+	jne	.not_idle
+	mov	ebx, [eax + TCP_SOCKET.t_idle]
+	cmp	ebx, [eax + TCP_SOCKET.t_rxtcur]
+	jle	.not_idle
+; We have been idle for a while and no ACKS are expected to clock out any data we send..
+; Slow start to get ack "clock" running again.
-	call	notify_network_event
+	mov	ebx, [eax + TCP_SOCKET.t_maxseg]
+	mov	[eax + TCP_SOCKET.SND_CWND], ebx
+  .not_idle:
+  .again:
+	mov	ebx, [eax + TCP_SOCKET.SND_NXT] 	; calculate offset
+	sub	ebx, [eax + TCP_SOCKET.SND_UNA] 	;
-	ret
+	mov	ecx, [eax + TCP_SOCKET.SND_WND] 	; determine window
+	cmp	ecx, [eax + TCP_SOCKET.SND_CWND]	;
+	jl	@f					;
+	mov	ecx, [eax + TCP_SOCKET.SND_CWND]	;
+       @@:						;
+	call	TCP_outflags
+; If in persist timeout with window of 0, send 1 byte.
+; Otherwise, if window is small but nonzero, and timer expired,
+; we will send what we can and go to transmit state
-  .exit:
+	test	[eax + TCP_SOCKET.t_force], -1
+	jz	.no_persist_timeout
+	test	ecx, ecx
+	jnz	.no_zero_window
+	cmp	ebx, [eax + SOCKET.SO_SND.SB_CC]
+	jge	@f
+	and	dl, not (TH_FIN)	  ; clear the FIN flag    ??? how can it be set before?
-	mov	[ebx + SOCKET_head.lock], 0
+       @@:
+	inc	ecx
-	ret
+	jmp	.no_persist_timeout
+  .no_zero_window:
+;;;        mov     [eax + TCP_SOCKET.t_timer....TCPT_PERSIST], 0
+	mov	[eax + TCP_SOCKET.t_rxtshift], 0
+  .no_persist_timeout:
+;;;106
+	mov	esi, [eax + SOCKET.SO_SND.SB_CC]
+	cmp	esi, ecx
+	jl	@f
+	mov	esi, ecx
+       @@:
+	sub	esi, ebx
+	cmp	esi, -1
+	jne	.not_minus_one
+; If FIN has been set, but not ACKed, and we havent been called to retransmit,
+; len (esi) will be -1
+; Otherwise, window shrank after we sent into it.
+; If window shrank to 0, cancel pending retransmit and pull SND_NXT back to (closed) window
+; We will enter persist state below.
+; If window didn't close completely, just wait for an ACK
+	xor	esi, esi
   .fail:
-	add	esp, 8
-	mov	[ebx + SOCKET_head.lock], 0
+	test	ecx, ecx
-	ret
+	jnz	@f
-align 4
-stateTCB_SYN_SENT:
+;;;        mov     [eax + TCP_SOCKET.t_timer..TCPT_REXMT], 0
-	DEBUGF	1,"TCBStateHandler: Syn_Sent\n"
-	; We are awaiting an ACK to our SYN, with a SYM
-	; Look at control flags - expecting an ACK
-	mov	al, [edx + TCP_Packet.Flags]
+	push	[eax + TCP_SOCKET.SND_UNA]
+	pop	[eax + TCP_SOCKET.SND_NXT]
-	test	al, TH_RST
+       @@:
-	jnz	.reset			; jump if RST bit set
+  .not_minus_one:
-	push	[edx + TCP_Packet.SequenceNumber]				     ;;
-	pop	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.RCV_NXT]	     ;;
-	inc_INET (ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.RCV_NXT)      ;;
 ;;; 124
-	push	[edx + TCP_Packet.AckNumber]					    ;;;;;;
-	pop	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.SND_NXT]	    ;;;;;;
-	and	al, TH_SYN + TH_ACK
-	jz	.exit			; jump if none of the following is set: RST, SYN, ACK
+	cmp	esi, [eax + TCP_SOCKET.t_maxseg]
-	test	al, TH_ACK
-	jz     .onlysyn 		; jump if only SYN bit is set
-	; If we arrived here, SYN and ACK are set
+	jle	@f
-	mov	[ebx +	SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.state], TCB_ESTABLISHED
-	pushw	TH_ACK
-  .send:	; Send an ACK
+	mov	esi, [eax + TCP_SOCKET.t_maxseg]
-	mov	eax, ebx
-	pop	bx
-	push	eax
-	xor	ecx, ecx
+	;sendalot = 1
-	call	TCP_send
+       @@:
+;;; 128
+	mov	edi, [eax + TCP_SOCKET.SND_NXT]
-	pop	ebx
+	add	edi, esi	; len
+	sub	edi, [eax + TCP_SOCKET.SND_UNA]
-  .exit:
+	add	edi, [eax + SOCKET.SO_SND.SB_CC]
+	cmp	edi, 0
-	mov	[ebx + SOCKET_head.lock], 0
+	jle	@f
-	ret
+	and	dl, not (TH_FIN)	  ; clear the FIN flag
-  .reset:
-	; TODO: ....
+       @@:
-	; remove all queued TCP packets for this connection !
-	mov	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.state], TCB_CLOSED
-	mov	[ebx + SOCKET_head.lock], 0
-	ret
-  .onlysyn:
-	mov	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.state], TCB_SYN_RECEIVED
-	pushw	TH_SYN + TH_ACK
-	jmp	.send
-align 4
-stateTCB_SYN_RECEIVED:
-	DEBUGF	1,"TCBStateHandler: Syn_received\n"
-	test	[edx + TCP_Packet.Flags], TH_RST	; reset connection? => LISTEN
-	jz	.check_ack
-	push	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.OrigRemotePort]
+;;;; 130 TODO: set window (ecx) to space in send buffer
-	pop	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.RemotePort]
-	push	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.OrigRemoteIP]
+;------------------------------
+; Sender silly window avoidance
+	test	esi, esi
+	jz	.zero_length
-	pop	[ebx + SOCKET_head.end + IPv4_SOCKET.RemoteIP]
-	mov	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.state], TCB_LISTEN
+	cmp	esi, [eax + TCP_SOCKET.t_maxseg]
-	jmp	.exit
+	je	.send
+;;; TODO: 144-145
-  .check_ack:
+	test	[eax + TCP_SOCKET.t_force], -1
+	jnz	.send
-	test	[edx + TCP_Packet.Flags], TH_ACK	; ACK? => connection established!
-	jz	.exit
+;;; TODO: 149..152
-	mov	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.state], TCB_ESTABLISHED
-	mov	eax, ebx
-	call	notify_network_event
-  .exit:
-	mov	[ebx + SOCKET_head.lock], 0
-	ret
-if 0
+  .zero_length:
-align 4
-stateTCB_ESTABLISHED:
+;----------------------------------------
+; Check if a window update should be sent
-	DEBUGF	1,"TCBStateHandler: Established\n"
-	mov	eax, [ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.RCV_NXT]
-	bswap	eax
+	cmp	ecx, 0	; window
-	DEBUGF	1,"RCV_NXT is set to:%u\n", eax
+	jle	.no_window
+;;; TODO 154-172
-	bswap	eax
-	cmp	eax, [edx + TCP_Packet.SequenceNumber]
+  .no_window:
-	jne	.exit					;;;;;;
+;--------------------------
+; Should a segment be sent?
-; check if we received an ACK
+	test	[ebx + TCP_SOCKET.t_flags], TF_ACKNOW
-	test	[edx + TCP_Packet.Flags], TH_ACK
+	jnz	.send
+	test	dl, TH_SYN + TH_RST
-	jz	.no_ack
+	jnz	.send
+	mov	eax, [ebx + TCP_SOCKET.SND_UP]
+	cmp	eax, [ebx + TCP_SOCKET.SND_UNA]
-	mov	ax, [edx + TCP_Packet.Window]
+	jg	.send
+	test	dl, TH_FIN
+	jz	.enter_persist
+	test	[ebx + TCP_SOCKET.t_flags], TF_SENTFIN
+	jnz	.send
+	mov	eax, [ebx + TCP_SOCKET.SND_NXT]
+	cmp	eax, [ebx + TCP_SOCKET.SND_UNA]
+	je	.send
+;--------------------
+; Enter persist state
+  .enter_persist:
-	xchg	al, ah
-	cmp	ax, 1024
-	ja	@f
+	DEBUGF	1,"Entering pesist state\n"
+;--------------------------------------
+; No reason to send a segment, just ret
+	DEBUGF	1,"No reason to send a segment\n"
+	ret
 	mov	[ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.wndsizeTimer], 1
-      @@:
-  .no_ack:
+;-----------------------------------------------
-; Now, see if we received any data
-	test	ecx, ecx
 	jz	.nodata
+; Send a segment
+;
+; ebx = socket pointer
+;  dl = flags
+;
+;-----------------------------------------------
+.send:
+	DEBUGF	1,"Preparing to send a segment\n"
+	xor	edi, edi	; edi will contain the number of header option bytes
+;------------------------------------
+; Send options with first SYN segment
+	test	dl, TH_SYN
+	jz	.no_options
+	mov	eax, [ebx + TCP_SOCKET.ISS]
+	mov	[ebx + TCP_SOCKET.SND_NXT], eax
 	test	[ebx + TCP_SOCKET.t_flags], TF_NOOPT
-; Calculate next sequencenumber
+	jnz	.no_options
-	add_INET (ebx + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.RCV_NXT)
+	mov	eax, TCP_OPT_MAXSEG shl 24 + 4 shl 16
-	push	edx
+	mov	 ax, 1280 ;;;;;;
-	DEBUGF	1,"Got %u bytes data!\n", ecx
-; calculate header length
+	bswap	eax
+	push	eax
-	movzx	eax, [edx + TCP_Packet.DataOffset]
+	mov	di, 4
-	and	eax, 11110000b
 	shr	eax, 2
-	DEBUGF	1,"TCP header size: %u\n", eax
-	add	edx, eax	; now edx points to data
-	add	esp, 4
-	pop	esi		; pointer to buffer
-	add	esp, 4
+	test	[ebx + TCP_SOCKET.t_flags], TF_REQ_SCALE
+	jz	.no_syn
+	test	dl, TH_ACK
+	jnz	.scale_opt
+	test	[ebx + TCP_SOCKET.t_flags], TF_RCVD_SCALE
+	jz	.no_syn
+  .scale_opt:
+	mov	eax, TCP_OPT_WINDOW shl 24 + 4 shl 16 + TCP_OPT_NOP
+	mov	 ah, byte [ebx + TCP_SOCKET.request_r_scale]
-	sub	edx, esi
+	bswap	eax
-	mov	edi, edx	; offset
-	mov	eax, ebx	; socket ptr
 	push	eax
+	add	di, 4
+  .no_syn:
+;------------------------------------
+; Make the timestamp option if needed
+	test	[ebx + TCP_SOCKET.t_flags], TF_REQ_TSTMP
+	jz	.no_timestamp
+	test	dl, TH_RST
+	jnz	.no_timestamp
+	test	dl, TH_ACK
+	jz	.timestamp
+	test	[ebx + TCP_SOCKET.t_flags], TF_RCVD_TSTMP
-	call	socket_internal_receiver	; Place the data from packet into socket
+	jz	.no_timestamp
+  .timestamp:
-;        lea     ebx, [eax + SOCKET_head.lock]
-;        call    wait_mutex
+	DEBUGF	1,"Creating a timestamp\n"
+	push	dword (TCP_OPT_TIMESTAMP shl 8 + 10 + TCP_OPT_NOP shl 16 + TCP_OPT_NOP shl 24)
+	pushw	0
+	mov	eax, [timer_ticks]
+	bswap	eax
+	push	eax
+	add	di, 10
+  .no_timestamp:
+	;; TODO: check if we dont exceed the max segment size
-	mov	ebx, eax
+  .no_options:
+	add	edi, TCP_segment.Data
+;-----------------------------------
+; Check if we have some data to send
-	pop	edx
+     ;;;   mov     ecx, [huppeldepup]
+	test	ecx, ecx
-	test	[edx + TCP_Packet.Flags], TH_FIN + TH_RST
+	jz	.no_data
-	jz	.ack
+	;;; 278-316
   .nodata:
-	test	[edx + TCP_Packet.Flags], TH_FIN + TH_RST
+	jmp	.header
 .error:
 	mov	eax, -1
 	ret
 .packets_tx:
-	add	eax, TCP_PACKETS_TX
+	add	eax, TCP_segments_tx
 	mov	eax, [eax]
 	ret
 .packets_rx:
-	add	eax, TCP_PACKETS_RX
+	add	eax, TCP_segments_rx

Subversion Repositories Kolibri OS

(root)/kernel/branches/net/network/tcp.inc – Rev 1473 → 1514