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

 ;;          GNU GENERAL PUBLIC LICENSE                             ;;
 ;;             Version 2, June 1991                                ;;
 ;;                                                                 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 1519 $
+$Revision: 1529 $
 ; Socket states
 TCB_CLOSED		equ 0
 ; timer constants
 TCP_max_rxtshift	equ 12		; max retransmissions waiting for ACK
+TCP_max_keepcnt 	equ 8		; max keepalive probes
+;
-TCP_max_keepcnt 	equ 8		; max keepalive probes
+TCP_max_winshift	equ 14
 TCP_max_win		equ 65535
 struct	TCP_segment
+;
 ; TCP_init
+;
 ;  This function resets all TCP variables
+;
-;  IN:  /
-;  OUT: /
-;
 ;-----------------------------------------------------------------
-align 4
-TCP_init:
+macro	TCP_init {
 	xor	eax, eax
 	mov	edi, TCP_segments_tx
 	mov	ecx, (6*IP_MAX_INTERFACES)
+	rep	stosd
-	rep	stosd
+	pseudo_random	eax
-	mov	[TCP_sequence_num], 1
+	mov	[TCP_sequence_num], eax
 	ret
+;----------------------
+;
-;----------------------
+;
 ;----------------------
 macro	TCP_timer_160ms {
 ;----------------------
-align 4
+local	.loop
 	jnz	.loop
 	DEBUGF	1,"TCP ack for socket %x expired, time to piggyback!\n", eax
 	push	eax
-	call	TCP_respond
+	call	TCP_respond_socket
 	pop	eax
 	jmp	.loop
   .exit:
+}
-	ret
+;-----------------------------------------------------------------
+;
 ;-----------------------------------------------------------------
 	jz	.exit
 	cmp	[eax + SOCKET.Type], IP_PROTO_TCP
+	jne	.loop
 	jne	.loop
 	inc	[eax + TCP_SOCKET.t_idle]
-	dec    [eax + TCP_SOCKET.timer_retransmission]
+	dec	[eax + TCP_SOCKET.timer_retransmission]
 	DEBUGF	1,"socket %x: persist timer expired\n", eax
+	jmp	.loop
+  .exit:
+}
+macro	TCP_checksum IP1, IP2 {
+;-------------
+; Pseudoheader
+	; protocol type
+	mov	edx, IP_PROTO_TCP
+	; source address
+	add	dl, byte [IP1+1+4]
+	adc	dh, byte [IP1+0+4]
+	adc	dl, byte [IP1+3+4]
+	adc	dh, byte [IP1+2+4]
+	; destination address
+	adc	dl, byte [IP2+1+8]
+	adc	dh, byte [IP2+0+8]
+	adc	dl, byte [IP2+3+8]
+	adc	dh, byte [IP2+2+8]
+	; size
+	adc	dl, cl
+	adc	dh, ch
+;---------------------
+; Real header and data
+	push	esi
-	jmp	.loop
+	call	checksum_1
+	call	checksum_2
+	pop	esi
-  .exit:
+}	; returns in dx only
 	ret
+;
 ;-----------------------------------------------------------------
 align 4
 TCP_input:
-       DEBUGF  1,"TCP_input\n"
        DEBUGF  1,"TCP_input size=%u\n", ecx
 ; 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
+	shr	al, 2
-	DEBUGF	1,"data offset: %u\n", eax
-	cmp	eax, 20
-	jl	.drop
+	DEBUGF	1,"headersize=%u\n", eax
-	cmp	eax, ecx
+	cmp	eax, 20
-	jg	.drop
+	jl	.drop
 ;-------------------------------
 ; Now, re-calculate the checksum
+	push	eax ecx edx
-	push	eax edx ebx
+	pushw	[edx + TCP_segment.Checksum]
-	push	edi
+	mov	[edx + TCP_segment.Checksum], 0
-	push	esi
+	push	esi edi
 	mov	esi, edx
-	call	TCP_checksum	; this destroys edx, ecx and esi (but not edi! :)
+	TCP_checksum
+	pop	esi edi ; yes, swap them (we dont need dest addr)
+	pop	cx	; previous checksum
+	cmp	cx, dx
 	pop	edx ecx esi
-	pop	ebx edx eax
+	jnz	.drop
-	cmp	[edx + TCP_segment.Checksum], 0
+	DEBUGF	1,"Checksum is correct\n"
 	jnz	.drop
+	sub	ecx, esi	; update packet size
-	DEBUGF	1,"Checksum is correct\n"
+	jl	.drop
 ;-----------------------------------------------------------------------------------------
 ; Check if this packet has a timestamp option (We do it here so we can process it quickly)
 	cmp	dword [edx + TCP_segment.Data], 0x0101080a	; Timestamp header
 	jne	.no_timestamp
 	DEBUGF	1,"timestamp ok\n"
-	; TODO: Parse the options
-	; TODO: Set a Bit in the TCP to tell all options are parsed
 	; TODO: Parse the option
-	ret
+	; TODO: Set a Bit in the TCP to tell all options are parsed
   .no_timestamp:
 ;-------------------------------------------
 ; Convert Big-endian values to little endian
+	ntohld	[edx + TCP_segment.SequenceNumber]
 	ntohld	[edx + TCP_segment.AckNumber]
 	ntohld	[edx + TCP_segment.SequenceNumber]
-	ntohld	[edx + TCP_segment.AckNumber]
+	ntohlw	[edx + TCP_segment.Window]
 	mov	ax, [edx + TCP_segment.DestinationPort]
 	cmp	[ebx + TCP_SOCKET.LocalPort], ax
 	jne	.socket_loop
 	mov	eax, [ebx + IP_SOCKET.RemoteIP]
-	cmp	eax, esi
+	cmp	eax, edi			; sender IP
 	je	@f
 	test	eax, eax
 	jnz	.socket_loop
 ; ebx now contains the pointer to the socket
 ;----------------------------
 ; Check if socket isnt closed
-	cmp	[TCP_SOCKET.t_state], TCB_CLOSED
+	cmp	[ebx + 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
+;;        add     ebx, SOCKET.lock ; TODO: figure out if we should lock now already
-;---------------------------------------
+;;        call    wait_mutex
-; unscale the window into a 32 bit value  ;;;;;;
+;;        sub     ebx, SOCKET.lock
 	DEBUGF	1,"Socket locked\n"
 	movzx	eax, [edx + TCP_segment.Window]
+;----------------------------------------------------------------------------------------
-	xchg	al, ah
+; unscale the window into a 32 bit value (notice that SND_SCALE must be initialised to 0)
-	test	[edx + TCP_segment.Flags], TH_SYN
+	movzx	eax, [edx + TCP_segment.Window]
-	jnz	.no_syn
+	push	cx
+	mov	cl, [ebx + TCP_SOCKET.SND_SCALE]
+	shl	eax, cl
-	mov	cl , [ebx + TCP_SOCKET.SND_SCALE]
+	pop	cx
+	;;;; do something with eax
-	shl	eax, cl
+;-----------------------------------
+; Is this socket a listening socket?
+;        test    [ebx + SOCKET.options], SO_ACCEPTCON
-  .no_syn:
+;        jnz     .listening_socket                       ;;;;; TODO
+;-------------------------------------
+; Reset idle timer and keepalive timer
-;-----------------------------------
+	mov	[ebx + TCP_SOCKET.t_idle], 0
+	mov	[ebx + TCP_SOCKET.timer_keepalive], TCP_time_keep_interval
+;--------------------
-; Is this socket a listening socket?
+; Process TCP options
-; If so, create a new socket
+	cmp	esi, 20 			; esi is headersize
+	je	.no_options
+	DEBUGF	1,"Segment has options\n"
+	test	[ebx + TCP_SOCKET.t_state], TCB_LISTEN		; no options when in listen state
+	jz	.no_options
+	lea	edi, [edx + TCP_segment.Data]
+	lea	eax, [edx + esi]
+  .opt_loop:
+	cmp	edi, eax
+	jge	.no_options
+	cmp	byte [edi], TCP_OPT_EOL 	; end of option list?
+	jz	.no_options
+	cmp	byte [edi], TCP_OPT_NOP 	; nop ?
+	jz	.opt_nop
+	cmp	byte [edi], TCP_OPT_MAXSEG
+	je	.opt_maxseg
+	cmp	byte [edi], TCP_OPT_WINDOW
+	je	.opt_window
-	test	[ebx + SOCKET.options], SO_ACCEPTCON
-	jz	.no_accept_conn
+	cmp	byte [edi], TCP_OPT_TIMESTAMP
+	je	.opt_timestamp
-		; TODO: create a new socket
+	jmp	.no_options	; If we reach here, some unknown options were received, skip them all!
+  .opt_nop:
+	inc	edi
+	jmp	.opt_loop
+  .opt_maxseg:
+	cmp	byte [edi+1], 4
+	jne	.no_options		; error occured, ignore all options!
+	test	[edx + TCP_segment.Flags], TH_SYN
+	jz	@f
+	DEBUGF	1,"Got maxseg option"
+	;;;;;
+       @@:
+	add	edi, 4
+	jmp	.opt_loop
+  .opt_window:
 	cmp	byte [edi+1], 3
-  .no_accept_conn:
+	jne	.no_options
 ;----------------------------
-; Compute window scale factor
+	test	[edx + TCP_segment.Flags], TH_SYN
 	jz	@f
-; TODO
+	DEBUGF	1,"Got window option"
 ;      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
+	cmp	[ebx + TCP_SOCKET.t_state], TCB_ESTABLISHED
 	jnz	.not_uni_xfer
-	test	[TCP_segment.Flags], TH_SYN + TH_FIN + TH_RST + TH_URG
+	test	[edx + TCP_segment.Flags], TH_SYN + TH_FIN + TH_RST + TH_URG
 	jnz	.not_uni_xfer
-	test	[TCP_segment.Flags], TH_ACK
+	test	[edx + 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] ;;;;;
+	movzx	eax, [edx + TCP_segment.Window] ;;;;; (should use pre-calculated value isntead: todo: figure out where to store it)
-	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.
+	cmp	eax, [ebx + TCP_SOCKET.SND_WND]
 	jne	.not_uni_xfer
 	; TODO: check if it has a timestamp
 	mov	eax, [ebx + TCP_SOCKET.SND_NXT]
+	cmp	eax, [ebx + TCP_SOCKET.SND_MAX]
-;---------------------------------------
-; check if we are sender in the uni-xfer
+	jne	.not_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
+; check if we are sender in the uni-xfer
 ; - The acknowledgment field in the segment (ti_ack) is less than or equal to the maximum sequence number sent (snd_max).
 ; If the following 4 conditions are all true, this segment is a pure ACK.
 ;        mov     eax, [edx + TCP_segment.Ack]
+; - The segment contains no data.
+	test	ecx, ecx
+	jnz	.not_sender
+; - The congestion window is greater than or equal to the current send window.
+;     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
 	cmp	eax, [ebx + TCP_SOCKET.SND_MAX]
-	jg	.not_uni_xfer
+; - The acknowledgment field in the segment is less than or equal to the maximum sequence number sent.
 	mov	ecx, [edx + TCP_segment.AckNumber]
-; - The congestion window (snd_cwnd) is greater than or equal to the current send window (snd_wnd).
+	cmp	ecx, [ebx + TCP_SOCKET.SND_MAX]
-;     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.
+	jg	.not_uni_xfer
+; - The acknowledgment field in the segment is greater than the largest unacknowledged sequence number.
+	sub	ecx, [ebx + TCP_SOCKET.SND_UNA]
+	jle	.not_uni_xfer
-	mov	eax, [ebx + TCP_SOCKET.SND_CWND]
+	DEBUGF	1,"Header prediction: we are sender\n"
 	cmp	eax, [ebx + TCP_SOCKET.SND_WND]
 ; Generate more output
 	call	TCP_output
-	jmp	.drop
 	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)
+  .not_sender:
 ; - The amount of data in the segment 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.
+; - The acknowledgment field 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).
+	mov	eax, [edx + TCP_segment.AckNumber]
-;;;;
+	cmp	eax, [ebx + TCP_SOCKET.SND_UNA]
-	jnz	.not_uni_xfer
+	jne	.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
+; - The reassembly list of out-of-order segments for the connection is empty (seg_next equals tp). ;;;;;;;
-	DEBUGF	1,"header prediction: we are receiver\nreceiving %u bytes of data\n", ecx
+	jnz	.not_uni_xfer
+;-------------------------------------
-; The next expected receive sequence number (rcv_nxt) is incremented by the number of bytes of data.
+; Complete processing of received data
-	add	[ebx + TCP_SOCKET.RCV_NXT], ecx
-; Add the data to the socket buffer
 	mov	eax, ebx
-	;;; mov...
+	DEBUGF	1,"header prediction: we are receiver\nreceiving %u bytes of data\n", ecx
 	call	SOCKET_input
 	add	esi, edx
-; The delayed-ACK flag is set and the input processing is complete.
-	jmp	.drop
-;----------------------------------------------------
-; Header prediction failed, doing it the slow way..
-  .not_uni_xfer:
+	lea	eax, [ebx + rcv]
 	call	SOCKET_ring_add 			; Add the data to the socket buffer
 	DEBUGF	1,"Header prediction failed\n"
-;------------------------
+	add	[ebx + TCP_SOCKET.RCV_NXT], ecx 	; Update sequence number with number of bytes we have copied
-; calculate header length                               ;;;;; we already calculated this before!
+	or	[ebx + TCP_SOCKET.t_flags], TF_DELACK	; Set delayed ack flag
 	movzx	eax, [edx + TCP_segment.DataOffset]
-	and	eax, 0xf0
+	jmp	.drop
 	shr	eax, 2
+;----------------------------------------------------
-; Update edx to point to data..
+; Header prediction failed, doing it the slow way..     ;;;;; current implementation of header prediction destroys some regs (ecx) !!
-	add	edx, eax
 ; ..and ecx to give data size
-	sub	ecx, eax
+  .not_uni_xfer:
 ;------------------------------
-; Calculate receive window size
+	DEBUGF	1,"Header prediction failed\n"
-	;;;;
+;------------------------------
 ; Calculate receive window size
+	;;;;
 ;-------------------------
-;-------------------------
+; TCP slow input procedure
 ; TCP slow input procedure
 	jnz	.drop_with_reset
 	test	[edx + TCP_segment.Flags], TH_SYN
+	jz	.drop
 	jz	.drop
+	; TODO: find sender ip address somewhere!
+	; TODO: check if it's a broadcast or multicast, and drop if so
-	; TODO: check if it's a broadcast or multicast, and drop if so
+	call	SOCKET_fork
-;;; 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
+	jz	.drop		; if we could not open a new connection, drop segment (;;;; should we send RST too?)
-; 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
+; Fill in some variables
+	add	[TCP_sequence_num], 64000
-;; Push pointer to new socket to queue
-;        movzx   ecx, [ebx + TCP_SOCKET.backlog_cur]
+	push	[edx + TCP_segment.SourcePort]
-;        inc     [ebx + TCP_SOCKET.backlog_cur]
+	pop	[eax + TCP_SOCKET.RemotePort]
-;        mov     [ebx + TCP_SOCKET.end + ecx*4], eax
+	push	[edx + TCP_segment.SequenceNumber]
-	mov	[eax + IP_SOCKET.RemoteIP], esi ; IP source address
+	pop	[eax + TCP_SOCKET.IRS]
+	push	[eax + TCP_SOCKET.ISS]
 	pop	[eax + TCP_SOCKET.SND_NXT]
 	mov	cx, [edx + TCP_segment.SourcePort]
-	mov	[eax + TCP_SOCKET.RemotePort], cx
+	mov	[eax + TCP_SOCKET.t_state], TCB_SYN_RECEIVED
 	mov	eax, [edx + TCP_segment.AckNumber]
 	cmp	eax, [ebx + TCP_SOCKET.ISS]
-	jle	.drop_with_reset
+	jle	.drop_with_reset
-	mov	eax, [edx + TCP_segment.AckNumber]
-	cmp	eax, [ebx + TCP_SOCKET.SND_MAX]
+	DEBUGF	1,"snd_max = %x\n", [ebx + TCP_SOCKET.SND_MAX]	 ;;; TODO: set this, but where?
+;        mov     eax, [edx + TCP_segment.AckNumber]
-	jg	.drop_with_reset
+;;        cmp     eax, [ebx + TCP_SOCKET.SND_MAX]
-       @@:
+;;        jg      .drop_with_reset
        @@:
        @@:
 	test	[edx + TCP_segment.Flags], TH_SYN
 	jz	.drop
 ; at this point, segment seems to be valid
-; now, process received SYN in response to an active open
+	test	[edx + TCP_segment.Flags], TH_ACK
+	jz	.no_syn_ack
 	test	[edx + TCP_segment.Flags], TH_ACK
-	jz	@f
+; now, process received SYN in response to an active open
-	mov	eax, [edx + TCP_segment.AckNumber]
 	mov	[ebx + TCP_SOCKET.SND_UNA], eax
 	mov	eax, [edx + TCP_segment.AckNumber]
-	mov	eax, [ebx + TCP_SOCKET.SND_UNA]
+	mov	[ebx + TCP_SOCKET.SND_UNA], eax
+	cmp	eax, [ebx + TCP_SOCKET.SND_NXT]
-	cmp	eax, [ebx + TCP_SOCKET.SND_NXT]
 	jle	@f
+	mov	[ebx + TCP_SOCKET.SND_NXT], eax
+       @@:
-	mov	[ebx + TCP_SOCKET.SND_NXT], eax
+  .no_syn_ack:
+	mov	[ebx + TCP_SOCKET.timer_retransmission], 0	; disable retransmission
+	push	[edx + TCP_segment.SequenceNumber]
+	pop	[ebx + TCP_SOCKET.IRS]
+;;; TODO: tcp_rcvseqinit
+	mov	[ebx + TCP_SOCKET.t_flags], TF_ACKNOW
+	mov	eax, [ebx + TCP_SOCKET.SND_UNA]
+	cmp	eax, [ebx + TCP_SOCKET.ISS]
+	jle	.simultaneous_open
-	mov	[ebx + TCP_SOCKET.timer_keepalive], TCP_time_keep_interval
+	test	[edx + TCP_segment.Flags], TH_ACK
-	mov	[ebx + TCP_SOCKET.timer_retransmission], 0
+	jz	.simultaneous_open
-	mov	eax, [edx + TCP_segment.SequenceNumber]
+	DEBUGF	1,"TCP: active open\n"
-	mov	[ebx + TCP_SOCKET.IRS], eax
+; TODO: update stats
+; TODO: set socket state to connected
-; TODO: set socket state to connected
+	mov	[ebx + TCP_SOCKET.t_state], TCB_ESTABLISHED
-	mov	[ebx + TCP_SOCKET.t_state], TCB_ESTABLISHED
+; TODO: check if we should scale the connection (567-572)
 	; TODO: 592
 	mov	cx, [ebx + TCP_SOCKET.RCV_WND]
 	; TODO...
        @@:
 	;;;;;
-	;;; jmp     .step6
+	jmp	.step6
 align 4
 	and	[edx + TCP_segment.Flags], not (TH_URG)
 	dec	eax
   .no_drop:
 	DEBUGF	1,"Going to drop %u bytes of data", eax
 ; eax holds number of bytes to drop
 ; eax holds number of bytes to drop
 ;----------------------------------
-; Check for entire duplicate packet
-	cmp	eax, ecx
-	jge	.duplicate
-	;;; TODO: figure 28.30
+; Check for entire duplicate packet
-;;        inc     [TCP_segments_rx]
+	cmp	eax, ecx
 	jge	.duplicate
 	dec	ecx
 	jne	@f
 	mov	eax, ecx
 	and	[edx + TCP_segment.Flags], not TH_FIN
-	;;; TODO: set ACKNOW flag
 	or	[ebx + TCP_SOCKET.t_flags], TF_ACKNOW
 	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
+	; Handle the case when a bound socket connects to itself
 	; Allow packets with a SYN and an ACKto continue with the processing
 	cmp	[edx + TCP_segment.Flags], TH_ACK
 	jz	.drop_after_ack
+  .duplicate:
-  .duplicate:
+	DEBUGF	1,"Duplicate received"
 ;----------------------------------------
 ; Update statistics for duplicate packets
 	;;; TODO
   .dont_drop_all:
   .no_excess_data:
   .no_excess_data:
 ; Process RST flags
 	test	[edx + TCP_segment.Flags], TH_RST
+	jz	.rst_skip
-	jz	.rst_skip
+	DEBUGF	1,"Got an RST flag"
 	mov	eax, [ebx + TCP_SOCKET.t_state]
 	shl	eax, 2
 	dd	.econnreset	;TCB_FIN_WAIT_2
 	dd	.rst_close	;TCB_TIMED_WAIT
+  .econnrefused:
-  .econnrefused:
+	DEBUGF	1,"Connection refused"
 	;;; TODO: debug info
+	jmp	.close
-	jmp	.close
+  .econnreset:
+	DEBUGF	1,"Connection reset"
-  .econnreset:
+	;;; TODO: debug info
+  .close:
 	DEBUGF	1,"Closing connection"
 	;;; TODO: debug info
-    .close:
+	;;; update stats
+;------------------------------------------
-;------------------------------------------
+; Remove acknowledged data from send buffer
-; Remove acknowledged data from send buffer
+	lea	eax, [ebx + snd]
 	mov	ecx, ecx		;;;; 943 - 956
-	;;;; 943 - 956
+	call	SOCKET_ring_free
 ;---------------------------------------
-;---------------------------------------
+; Wake up process waiting on send buffer
 ; Wake up process waiting on send buffer
 	;;; needoutput = 1
   .no_window_update:
   .no_window_update:
 ;-----------------
 ; Ignore bogus urgent offsets
 	;;; 1040-1050
 	movzx	eax, [edx + TCP_segment.UrgentPointer]
-	add	eax, [ebx + SOCKET.SO_RCV.SB_CC]
+	add	eax, [ebx + rcv.size]
 	cmp	eax, SOCKET_MAXDATA
 	jle	.not_urgent
   .not_urgent:
 ;--------------------------------------
 ; processing of received urgent pointer
-	;;; 1051-1093
+	;;; TODO (1051-1093)
-align 4
+;--------------------------------
-.do_data:
+; process the data in the segment
-	DEBUGF	1,"Do data:\n"
+  .do_data:
-	; process the data in the segment
+	DEBUGF	1,"TCP: do data:\n"
 	jmp	.final_processing
   .dont_do_data:
   .dont_do_data:
 	;test    ;;;needoutput = 1
 	;jnz     .outputnow
+	test	[ebx + TCP_SOCKET.t_flags], TF_ACKNOW
+	jnz	.ack_now
+	mov	[ebx + SOCKET.lock], 0
+	call	kernel_free
+	add	esp, 4
+	ret
+  .ack_now:
-	test	[ebx + TCP_SOCKET.t_flags], TF_ACKNOW
+	DEBUGF	1,"ACK now!\n"
 	jz	.ret
+	push	ebx
-  .outputnow:
+	mov	eax, ebx
-	call	TCP_output
 	call	TCP_output
+	pop	ebx
-  .ret:
 	mov	[ebx + SOCKET.lock], 0
 	call	kernel_free
-	call	kernel_free
+	add	esp, 4
 	test	[edx + TCP_segment.Flags], TH_RST
 	jnz	.drop
+	and	[ebx + TCP_SOCKET.t_flags], TF_ACKNOW
-	and	[ebx + TCP_SOCKET.t_flags], TF_ACKNOW
+	push	ebx
+	mov	eax, ebx
 	call	TCP_output
-	call	TCP_output
 	pop	ebx
 	mov	[ebx + SOCKET.lock], 0
 	call	kernel_free
-	call	kernel_free
+	add	esp, 4
 	test	[edx + TCP_segment.Flags], TH_SYN
 	jnz	.respond_syn
 	mov	[ebx + SOCKET.lock], 0
+	mov	[ebx + SOCKET.lock], 0
+	call	kernel_free
-	call	kernel_free
+	add	esp, 4
-	ret	4
+	ret
   .respond_ack:
 	;;;;
-	call	TCP_respond
+	call	TCP_respond_segment
 	jmp	.destroy_new_socket
   .destroy_new_socket:
 	;;;; kill the newly created socket
 	mov	[ebx + SOCKET.lock], 0
-	call	kernel_free
-	ret	4
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;---------------------
-;
-; TCP_do_options
-;
-;-------------------
-align 4
-TCP_do_options:
-	DEBUGF	1,"TCP_do_options\n"
+	mov	[ebx + SOCKET.lock], 0
-	push	eax
-	sub	eax, 20
-	jz	.no_options
-	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
-;------------------
-; We have an option
-	movzx	edi, byte [esi + 1]		; get the length of this option in edi
-;--------------------------------------
-; Check for Maximum segment size option
-	cmp	byte [esi], TCP_OPT_MAXSEG
-	jne	.no_maxseg
-	cmp	edi, 4	; option length
-	jne	.continue
-	test	[edx + TCP_segment.Flags], TH_SYN
-	jz	.continue
-	; Now parse the option...
-	jmp	.continue
-  .no_maxseg:
-;------------------------
+	call	kernel_free
-; Check for Window option
-	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
-  .no_window:
-;---------------------------
-; Check for Timestamp option
-	cmp	byte [esi], TCP_OPT_TIMESTAMP
-	jne	.no_timestamp
-	cmp	edi, 10 ; option length
-	jne	.continue
-	; ...
-	jmp	.continue
-  .no_timestamp:
-;----------------------------------
-; Future options may be placed here
-;------------------------------
-; Continue scanning for options
-  .continue:
-	add	esi, edi
-	sub	eax, edi
-	jg	.loop
-  .no_options:
 	add	esp, 4
-	ret
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 	ret
 ;-----------------------------------------------------------------
 	cmp	ecx, [eax + TCP_SOCKET.SND_CWND]	;
 	jl	@f					;
 	mov	ecx, [eax + TCP_SOCKET.SND_CWND]	;
        @@:						;
-	call	TCP_outflags
+	call	TCP_outflags	; in dl
 ; If in persist timeout with window of 0, send 1 byte.
 	jz	.no_persist_timeout
 	test	ecx, ecx
 	jnz	.no_zero_window
-	cmp	ebx, [eax + SOCKET.SO_SND.SB_CC]
+	cmp	ebx, [eax + snd.size]
 	jge	@f
 	and	dl, not (TH_FIN)	  ; clear the FIN flag    ??? how can it be set before?
        @@:
 	inc	ecx
 	jmp	.no_persist_timeout
   .no_zero_window:
-;;;        mov     [eax + TCP_SOCKET.t_timer....TCPT_PERSIST], 0
+	mov	[eax + TCP_SOCKET.timer_persist], 0	;;;;
 	mov	[eax + TCP_SOCKET.t_rxtshift], 0
   .no_persist_timeout:
 	xor	esi, esi
 	test	ecx, ecx
 	jnz	@f
-;;;        mov     [eax + TCP_SOCKET.t_timer..TCPT_REXMT], 0
+	mov	[eax + TCP_SOCKET.timer_retransmission], 0   ; cancel retransmit
 ;;; 128
 	mov	edi, [eax + TCP_SOCKET.SND_NXT]
 	add	edi, esi	; len
 	sub	edi, [eax + TCP_SOCKET.SND_UNA]
-	add	edi, [eax + SOCKET.SO_SND.SB_CC]
+	add	edi, [eax + snd.size]
 	cmp	edi, 0
 	jle	@f
 	and	dl, not (TH_FIN)	  ; clear the FIN flag
+       @@:
-       @@:
+; set ecx to space available in receive buffer
-;;;; 130 TODO: set window (ecx) to space in send buffer
+; From now on, ecx will be the window we advertise to the other end
 ;------------------------------
-; Sender silly window avoidance
+	mov	ecx, SOCKET_MAXDATA
 	sub	ecx, [eax + rcv.size]
 	test	esi, esi
+;------------------------------
-	jz	.zero_length
+; Sender silly window avoidance
+	cmp	ecx, [eax + TCP_SOCKET.t_maxseg]
-	cmp	esi, [eax + TCP_SOCKET.t_maxseg]
+	je	.send
+;;; TODO: 144-145
-	je	.send
+	test	[eax + TCP_SOCKET.t_force], -1
 	jnz	.send
-;;; TODO: 144-145
+	mov	ebx, [eax + TCP_SOCKET.max_sndwnd]
-	test	[eax + TCP_SOCKET.t_force], -1
+	shr	ebx, 1
-	jnz	.send
+	cmp	ecx, ebx
   .enter_persist:
-	DEBUGF	1,"Entering persist state\n"
 	DEBUGF	1,"Entering persist state\n"
 ;--------------------------------------
-; No reason to send a segment, just ret
-	DEBUGF	1,"No reason to send a segment\n"
 ; No reason to send a segment, just ret
 	ret
 	DEBUGF	1,"No reason to send a segment\n"
+	ret
 ;-----------------------------------------------
+;
 ; Send a segment
 ;
+; eax = socket pointer
+;  dl = flags
+;
-; ebx = socket pointer
+;-----------------------------------------------
 ;  dl = flags
   .send:
 ;-----------------------------------------------
+	DEBUGF	1,"Preparing to send a segment\n"
-.send:
+	mov	edi, TCP_segment.Data	; edi will contain headersize
 	DEBUGF	1,"Preparing to send a segment\n"
+	sub	esp, 8			; create some space on stack
+	push	eax			; save this too..
-	xor	edi, edi	; edi will contain the number of header option bytes
 ;------------------------------------
-; Send options with first SYN segment
+; Send options with first SYN segment
-	test	dl, TH_SYN
-	jz	.no_options
+	test	dl, TH_SYN
 	jz	.no_options
 	mov	eax, [ebx + TCP_SOCKET.ISS]
-	mov	[ebx + TCP_SOCKET.SND_NXT], eax
+	push	[eax + TCP_SOCKET.ISS]
 	pop	[eax + TCP_SOCKET.SND_NXT]
 	test	[ebx + TCP_SOCKET.t_flags], TF_NOOPT
-	jnz	.no_options
-	mov	eax, TCP_OPT_MAXSEG shl 24 + 4 shl 16
+	test	[eax + TCP_SOCKET.t_flags], TF_NOOPT
+	jnz	.no_options
-	mov	 ax, 1280 ;;;;;;
-	bswap	eax
+	mov	ecx, 1460
-	push	eax
 	or	ecx, TCP_OPT_MAXSEG shl 24 + 4 shl 16
-	mov	di, 4
+	bswap	ecx
 	push	ecx
-	test	[ebx + TCP_SOCKET.t_flags], TF_REQ_SCALE
+	add	di, 4
-	jz	.no_syn
 	test	[eax + TCP_SOCKET.t_flags], TF_REQ_SCALE
-	test	dl, TH_ACK
+	jz	.no_syn
 	jnz	.scale_opt
 	test	dl, TH_ACK
-	test	[ebx + TCP_SOCKET.t_flags], TF_RCVD_SCALE
+	jnz	.scale_opt
-	jz	.no_syn
 	test	[eax + TCP_SOCKET.t_flags], TF_RCVD_SCALE
-  .scale_opt:
+	jz	.no_syn
-	mov	eax, TCP_OPT_WINDOW shl 24 + 4 shl 16 + TCP_OPT_NOP
+  .scale_opt:
-	mov	 ah, byte [ebx + TCP_SOCKET.request_r_scale]
+	movzx	ecx, byte [eax + TCP_SOCKET.request_r_scale]
-	bswap	eax
-	push	eax
+	or	ecx, TCP_OPT_WINDOW shl 24 + 4 shl 16 + TCP_OPT_NOP shl 8
+	bswap	ecx
-	add	di, 4
-  .no_syn:
 	pushd	ecx
-;------------------------------------
+	add	di, 4
-; Make the timestamp option if needed
-	test	[ebx + TCP_SOCKET.t_flags], TF_REQ_TSTMP
+  .no_syn:
-	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
+; Make the timestamp option if needed
-	jz	.no_timestamp
-  .timestamp:
-	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
+	test	[eax + TCP_SOCKET.t_flags], TF_REQ_TSTMP
+	jz	.no_timestamp
-  .no_timestamp:
-	;; TODO: check if we dont exceed the max segment size
-  .no_options:
-	add	edi, TCP_segment.Data
-;-----------------------------------
-; Check if we have some data to send
-     ;;;   mov     ecx, [huppeldepup]
-	test	ecx, ecx
-	jz	.no_data
-	;;; 278-316
+	test	dl, TH_RST
-	jmp	.header
-  .no_data:
+	jnz	.no_timestamp
-	;;; 317-338
+	test	dl, TH_ACK
+	jz	.timestamp
+	test	[eax + TCP_SOCKET.t_flags], TF_RCVD_TSTMP
+	jz	.no_timestamp
+  .timestamp:
+	mov	esi, [timer_ticks]
+	bswap	esi
-;----------
+	push	esi
+	pushw	0
+	pushd	TCP_OPT_TIMESTAMP + 10 shl 8 + TCP_OPT_NOP shl 16 + TCP_OPT_NOP shl 24
+	add	di, 10
-	push	di dx ebx
+  .no_timestamp:
-	add	ecx, edi	; total TCP segment size
-	mov	eax, [ebx + IP_SOCKET.RemoteIP]
+	;; TODO: check if we dont exceed the max segment size
-	mov	ebx, [ebx + IP_SOCKET.LocalIP]
-	mov	di , IP_PROTO_TCP
-	call	IPv4_create_packet
+  .no_options:
-;;;;        jz      .fail
+	; eax = socket ptr
+	; edx = flags
+	; ecx = data size
+	; edi = header size
+	; esi = snd ring buff ptr
+	xor	ecx, ecx	;;;;;
+	add	ecx, edi	; total TCP segment size
-	push	edx eax
-	call	[ebx + NET_DEVICE.transmit]
-	ret
+; Start by pushing all TCP header values in reverse order on stack
+; (essentially, creating the tcp header!)
-;----------------
+	pushw	0	;        .UrgentPointer          dw ?
+	pushw	0	;        .Checksum               dw ?
+	pushw	0x00a0	;        .Window                 dw ?    ;;;;;;;
+	shl	edi, 2	;        .DataOffset             db ?  only 4 left-most bits
+	shl	dx, 8
+	or	dx, di	;        .Flags                  db ?
+	pushw	dx
+	shr	edi, 2	;        .DataOffset             db ? ;;;;
+	push	[eax + TCP_SOCKET.RCV_NXT]	;        .AckNumber              dd ?
+	ntohld	[esp]
+	push	[eax + TCP_SOCKET.SND_NXT]	;        .SequenceNumber         dd ?
+	ntohld	[esp]
 ;-------------------------------
-; Now, create the 20-byte header
+	push	[eax + TCP_SOCKET.RemotePort]	;        .DestinationPort        dw ?
+	ntohlw	[esp]
-  .header:
+	push	[eax + TCP_SOCKET.LocalPort]	;        .SourcePort             dw ?
-;-----------------------
-; Fill in the TCP header
+	ntohlw	[esp]
-	pop	esi
-	push	[esi + TCP_SOCKET.SND_NXT]
-	rol	word [esp], 8
-	rol	dword [esp], 16
+	push	edi	; header size
-	pop	[edi + TCP_segment.SequenceNumber]
-	push	[esi + TCP_SOCKET.RCV_NXT]
-	rol	word [esp], 8
-	rol	dword [esp], 16
+; Create the IP packet
-	pop	[edi + TCP_segment.AckNumber]
+	mov	ebx, [eax + IP_SOCKET.LocalIP]	; source ip
-	push	[esi + TCP_SOCKET.LocalPort]
+	mov	eax, [eax + IP_SOCKET.RemoteIP] ; dest ip
-	rol	word [esp], 8
+;        mov     ecx,                            ; data length
-	pop	[edi + TCP_segment.SourcePort]
+;        mov     dx,                             ; fragment id
+	mov	di, IP_PROTO_TCP shl 8 + 128
+	call	IPv4_output
+	jz	.fail
-	push	[esi + TCP_SOCKET.RemotePort]
+;-----------------------------------------
-	rol	word [esp], 8
+; Move TCP header from stack to TCP packet
 	pop	[edi + TCP_segment.DestinationPort]
 ;        pop     ecx                     ; header size
-	mov	[edi + TCP_segment.Window], 0x0005
-	; 1280 bytes
-	mov	[edi + TCP_segment.UrgentPointer], 0
+;        mov     esi, esp
 ;        add     esp, ecx
-	mov	[edi + TCP_segment.DataOffset], 0x50
+;        shr     ecx, 2
+;        rep     movsd
+	mov	ecx, [esp]
+	lea	esi, [esp+4]
+	shr	ecx, 2
+	rep	movsd
+	pop	ecx
+	add	esp, ecx
 	mov	[esp + 3*4+4], edx	; packet size
-	mov	[edi + TCP_segment.Flags], cl
+	mov	[esp + 3*4], eax	; packet ptr
-	mov	[edi + TCP_segment.Checksum], 0
+	mov	edx, edi
 	sub	edx, ecx
 	db	TH_SYN + TH_ACK 	; TCB_LAST_ACK
 	db		 TH_ACK 	; TCB_FIN_WAIT_2
 	db		 TH_ACK 	; TCB_TIMED_WAIT
 ;-------------------------
+;
 ; TCP_drop
-;---------------------------------------
-; TCP_ack
+;---------------------------------------
 ;
-; The easy way to send an ACK/RST/keepalive segment
-;
-;  IN:  eax = socket ptr
-;       -or-
+; The easy way to send an ACK/RST/keepalive segment
+;
-;       edx = packet ptr (eax must be 0)
+; TCP_respond_socket:
 ;        cl = flags
-;
+;  IN:  ebx = socket ptr
-;  OUT: /
+;        cl = flags
 ;
-;---------------------------------------
+;--------------------------------------
 align 4
-TCP_respond:
+TCP_respond_socket:
-	DEBUGF	1,"TCP_respond\n"
+	DEBUGF	1,"TCP_respond_socket\n"
 ;---------------------
 ; Create the IP packet
-	push	cx eax edx
+	push	cx ebx
-	mov	ebx, [eax + IP_SOCKET.LocalIP]
+	mov	eax, [ebx + IP_SOCKET.RemoteIP]
-	mov	eax, [eax + IP_SOCKET.RemoteIP]
-	mov	ecx, TCP_segment.Data
-	mov	di , IP_PROTO_TCP
-	call	IPv4_create_packet
-	test	edi, edi
+	mov	ebx, [ebx + IP_SOCKET.LocalIP]
-	jz	.error
-;---------------------------
-; Now fill in the TCP header
-	pop	ecx
-	pop	esi
+	mov	ecx, TCP_segment.Data
+	mov	di , IP_PROTO_TCP shl 8 + 128
+	call	IPv4_output
+	test	edi, edi
+	jz	.error
+	pop	esi cx
+	push	edx eax
+;-----------------------------------------------
+; Fill in the TCP header by using the socket ptr
+	mov	ax, [esi + TCP_SOCKET.LocalPort]
+	rol	ax, 8
+	stosw
+	mov	ax, [esi + TCP_SOCKET.RemotePort]
+	rol	ax, 8
+	stosw
+	mov	eax, [esi + TCP_SOCKET.SND_NXT]
+	bswap	eax
+	stosd
+	mov	eax, [esi + TCP_SOCKET.RCV_NXT]
+	bswap	eax
+	stosd
-	test	esi, esi
+	mov	al, 0x50	; Dataoffset: 20 bytes
-;        jz
+	stosb
 	mov	al, cl
 	stosb
-	push	edx eax
+	mov	ax, [esi + TCP_SOCKET.RCV_WND]
-	push	dword .checksum
+	rol	ax, 8
-	je    .use_segment
-	jmp   .use_socket
+	stosw			; window
+	xor	eax, eax
+	stosd			; checksum + urgentpointer
-;---------------------
-; Fill in the checksum
+;---------------------
 ; Fill in the checksum
   .checksum:
   .checksum:
-	push	[esi + IP_SOCKET.LocalIP]
+	sub	edi, TCP_segment.Data
-	push	[esi + IP_SOCKET.RemoteIP]
+	mov	ecx, TCP_segment.Data
-	lea	esi, [edi - 20]
+	xchg	esi, edi
-	xor	ecx, ecx
+	TCP_checksum (edi + IP_SOCKET.LocalIP), (esi + IP_SOCKET.RemoteIP)
+	mov	[esi+TCP_segment.Checksum], dx
+;--------------------
+; And send the segment
+	call	[ebx + NET_DEVICE.transmit]
+	ret
+  .error:
+	DEBUGF	1,"TCP_respond failed\n"
+	add	esp, 2+4
+	ret
+;-------------------------
+; TCP_respond.segment:
+;
+;  IN:  edx = segment ptr (a previously received segment)
+;        cl = flags
+align 4
+TCP_respond_segment:
+	DEBUGF	1,"TCP_respond_segment\n"
+;---------------------
-	call	TCP_checksum
+; Create the IP packet
-;--------------------
-; And send the segment
 	push	cx edx
-	call	[ebx + NET_DEVICE.transmit]
+	mov	ebx, [edx - 20 + IPv4_Packet.SourceAddress]	 ;;;; and what if ip packet had options?!
-	ret
+	mov	eax, [edx - 20 + IPv4_Packet.DestinationAddress]   ;;;
 	mov	ecx, TCP_segment.Data
-  .error:
+	mov	di , IP_PROTO_TCP shl 8 + 128
 	rol	ax, 8
 	stosw			; window
 	xor	eax, eax
 	stosd			; checksum + urgentpointer
-	ret
-;-----------------------------------------------
+;---------------------
-; Fill in the TCP header by using the socket ptr
+; Fill in the checksum
+  .checksum:
+	lea	esi, [edi - TCP_segment.Data]
+	mov	ecx, TCP_segment.Data
-  .use_socket:
-	mov	ax, [esi + TCP_SOCKET.LocalPort]
-	rol	ax, 8
-	stosw
-	mov	ax, [esi + TCP_SOCKET.RemotePort]
-	rol	ax, 8
-	stosw
-	mov	eax, [esi + TCP_SOCKET.SND_NXT]
-	bswap	eax
-	stosd
-	mov	eax, [esi + TCP_SOCKET.RCV_NXT]
-	bswap	eax
-	stosd
-	mov	al, 0x50	; Dataoffset: 20 bytes
-	stosb
-	mov	al, cl
-	stosb
+	TCP_checksum (esi - 20 + IPv4_Packet.DestinationAddress), (esi - 20 + IPv4_Packet.DestinationAddress)
-	mov	ax, [esi + TCP_SOCKET.RCV_WND]
-	rol	ax, 8
+	mov	[esi+TCP_segment.Checksum], dx
-	stosw			; window
+;--------------------
+; And send the segment
+	call	[ebx + NET_DEVICE.transmit]
-	xor	eax, eax
-	stosd			; checksum + urgentpointer
-	ret
-;-----------------------------------------------------------------
-;
-; TCP_checksum
-;
-; This is the fast procedure to create or check a UDP header
-;  - To create a new checksum, the checksum field must be set to 0 before computation
-;  - To check an existing checksum, leave the checksum as is,
-;     and it will be 0 after this procedure, if it was correct
-;
-;  IN:  push source ip
-;       push dest ip
-;
-;       esi = packet ptr
-;
-;  OUT: checksum is filled in in packet! (but also in dx)
-;
-;-----------------------------------------------------------------
-align 4
-TCP_checksum:
-;-------------
-; Pseudoheader
-	; protocol type
-	mov	edx, IP_PROTO_TCP		; NO shl 8 here ! (it took me ages to figure this one out)
-	; source address
-	add	dl, [esp+1+4]
-	adc	dh, [esp+0+4]
-	adc	dl, [esp+3+4]
-	adc	dh, [esp+2+4]
-	; destination address
-	adc	dl, [esp+1+8]
-	adc	dh, [esp+0+8]
-	adc	dl, [esp+3+8]
-	adc	dh, [esp+2+8]
-	; size
-	adc	dl, cl
-	adc	dh, ch
-;---------------------
+	ret
-; Real header and data
-	push	esi
-	call	checksum_1
-	call	checksum_2
 	pop	esi

Subversion Repositories Kolibri OS

(root)/kernel/branches/net/network/tcp.inc – Rev 1519 → 1529