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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2011. All rights reserved.    ;;
;; Distributed under terms of the GNU General Public License       ;;
;;                                                                 ;;
;;  Part of the tcp/ip network stack for KolibriOS                 ;;
;;                                                                 ;;
;;   Written by hidnplayr@kolibrios.org                            ;;
;;                                                                 ;;
;;    Based on the code of 4.4BSD                                  ;;
;;                                                                 ;;
;;          GNU GENERAL PUBLIC LICENSE                             ;;
;;             Version 2, June 1991                                ;;
;;                                                                 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 1774 $
 
;-----------------------------------------------------------------
;
; TCP_input:
;
;  IN:  [esp] = ptr to buffer
;       [esp+4] = buffer size
;       ebx = ptr to device struct
;       ecx = segment size
;       edx = ptr to TCP segment
;
;       esi = ipv4 source address
;       edi = ipv4 dest   address
;
;  OUT: /
;
;-----------------------------------------------------------------
align 4
TCP_input:
 
       DEBUGF  1,"TCP_input size=%u ", 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
 
	DEBUGF	1,"headersize=%u\n", eax
 
	cmp	eax, 20
	jl	.drop_not_locked
 
;-------------------------------
; Now, re-calculate the checksum
 
	push	eax ecx edx
	pushw	[edx + TCP_segment.Checksum]
	mov	[edx + TCP_segment.Checksum], 0
	push	esi edi
	mov	esi, edx
	TCP_checksum (esp), (esp+4)
	pop	esi edi ; yes, swap them (we dont need dest addr)
	pop	cx	; previous checksum
	cmp	cx, dx
	pop	edx ecx esi
	jnz	.drop_not_locked
 
	DEBUGF	1,"Checksum is correct\n"
 
	sub	ecx, esi	; update packet size
	jl	.drop_not_locked
	DEBUGF	1,"we got %u bytes of data\n", ecx
 
;-----------------------------------------------------------------------------------------
; Check if this packet has a timestamp option (We do it here so we can process it quickly)
 
	cmp	esi, 20 + 12					; Timestamp option is 12 bytes
	jl	.no_timestamp
	je	.is_ok
 
	cmp	byte [edx + TCP_segment.Data + 12], TCP_OPT_EOL ; end of option list
	jne	.no_timestamp
 
  .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
	jne	.no_timestamp
 
	DEBUGF	1,"timestamp ok\n"
 
	; TODO: Parse the option
	; TODO: Set a Bit in the TCP to tell all options are parsed
 
  .no_timestamp:
 
;-------------------------------------------
; Convert Big-endian values to little endian
 
	ntohd	[edx + TCP_segment.SequenceNumber]
	ntohd	[edx + TCP_segment.AckNumber]
 
	ntohw	[edx + TCP_segment.Window]
	ntohw	[edx + TCP_segment.UrgentPointer]
	ntohw	[edx + TCP_segment.SourcePort]
	ntohw	[edx + TCP_segment.DestinationPort]
 
;------------------------------------------------------------
; 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)
; (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_not_locked
 
	cmp	[ebx + SOCKET.Domain], AF_INET4
	jne	.socket_loop
 
	cmp	[ebx + SOCKET.Protocol], IP_PROTO_TCP
	jne	.socket_loop
 
	mov	ax, [edx + TCP_segment.DestinationPort]
	cmp	[ebx + TCP_SOCKET.LocalPort], ax
	jne	.socket_loop
 
	mov	eax, [ebx + IP_SOCKET.RemoteIP]
	cmp	eax, edi			; edi is source ip from packet
	je	@f
	test	eax, eax
	jnz	.socket_loop
       @@:
 
	mov	ax, [ebx + TCP_SOCKET.RemotePort]
	cmp	[edx + TCP_segment.SourcePort] , ax
	je	.found_socket
	test	ax, ax
	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	[ebx + TCP_SOCKET.t_state], TCB_CLOSED
	je	.drop_not_locked
 
;----------------
; Lock the socket
 
	add	ebx, SOCKET.lock
	DEBUGF	1,"lock: %x\n", [ebx]
	call	wait_mutex
	sub	ebx, SOCKET.lock
 
	DEBUGF	1,"Socket locked\n"
 
;---------------------------------------
; unscale the window into a 32 bit value
 
	movzx	eax, [edx + TCP_segment.Window]
	push	ecx
	mov	cl, [ebx + TCP_SOCKET.SND_SCALE]
	shl	eax, cl
	mov	dword [edx + TCP_segment.Window], eax	; word after window is checksum, we dont need checksum anymore
	pop	ecx
 
;-----------------------------------
; Is this socket a listening socket?
 
	test	[ebx + SOCKET.options], SO_ACCEPTCON
	jz	.no_listening_socket
 
	call	SOCKET_fork
	jz	.drop
 
	push	[edx + TCP_segment.DestinationPort]
	pop	[eax + TCP_SOCKET.LocalPort]
 
	push	[edx - IPv4_Packet.DataOrOptional + IPv4_Packet.DestinationAddress]	;;; FIXME
	pop	[eax + IP_SOCKET.LocalIP]
 
	push	[edx - IPv4_Packet.DataOrOptional + IPv4_Packet.SourceAddress]	   ;;; FIXME
	pop	[eax + IP_SOCKET.RemoteIP]
 
	mov	[eax + TCP_SOCKET.t_state], TCB_LISTEN
 
	jmp	.not_uni_xfer
 
  .no_listening_socket:
 
;-------------------------------------
; Reset idle timer and keepalive timer
 
	mov	[ebx + TCP_SOCKET.t_idle], 0
	mov	[ebx + TCP_SOCKET.timer_keepalive], TCP_time_keep_interval
 
;--------------------
; Process TCP options
 
	cmp	esi, 20 			; esi is headersize
	je	.no_options
 
	DEBUGF	1,"Segment has options\n"
 
	cmp	[ebx + TCP_SOCKET.t_state], TCB_LISTEN		; no options when in listen state
	jz	.not_uni_xfer					; also no header prediction
 
	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
 
	cmp	byte [edi], TCP_OPT_TIMESTAMP
	je	.opt_timestamp
 
	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
 
	movzx	eax, word[edi+2]
	rol	ax, 8
	DEBUGF	1,"Maxseg: %u\n", ax
 
	mov	[ebx + TCP_SOCKET.t_maxseg], eax
 
       @@:
	add	edi, 4
	jmp	.opt_loop
 
 
  .opt_window:
	cmp	byte [edi+1], 3
	jne	.no_options
 
	test	[edx + TCP_segment.Flags], TH_SYN
	jz	@f
 
	DEBUGF	1,"Got window option\n"
 
	;;;;;
       @@:
	add	edi, 3
	jmp	.opt_loop
 
 
  .opt_timestamp:
	cmp	byte [edi+1], 10
	jne	.no_options
 
	DEBUGF	1,"Got timestamp option\n"
 
	;;;;;
 
	add	edi, 10
	jmp	.opt_loop
 
  .no_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	[ebx + TCP_SOCKET.t_state], TCB_ESTABLISHED
	jnz	.not_uni_xfer
 
	test	[edx + TCP_segment.Flags], TH_SYN + TH_FIN + TH_RST + TH_URG
	jnz	.not_uni_xfer
 
	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
 
	mov	eax, dword [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
 
;---------------------------------------
; 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.
	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
 
; - The acknowledgment field in the segment is less than or equal to the maximum sequence number sent.
	mov	eax, [edx + TCP_segment.AckNumber]
	cmp	eax, [ebx + TCP_SOCKET.SND_MAX]
	jg	.not_uni_xfer
 
; - The acknowledgment field in the segment is greater than the largest unacknowledged sequence number.
	sub	eax, [ebx + TCP_SOCKET.SND_UNA]
	jle	.not_uni_xfer
 
	DEBUGF	1,"Header prediction: we are sender\n"
 
;---------------------------------
; Packet is a pure ACK, process it
 
; Update RTT estimators
 
;;; TODO
 
; Delete acknowledged bytes from send buffer
	pusha
	mov	ecx, eax
	lea	eax, [ebx + STREAM_SOCKET.snd]
	call	SOCKET_ring_free
	popa
 
; update window pointers
	mov	eax, [edx + TCP_segment.AckNumber]
	mov	[ebx + TCP_SOCKET.SND_UNA], eax
 
; Stop retransmit timer
	mov	[ebx + TCP_SOCKET.timer_ack], 0
 
; Awaken waiting processes
	mov	[ebx + SOCKET.lock], 0
	mov	eax, ebx
	call	SOCKET_notify_owner
 
; Generate more output
	call	TCP_output
 
	jmp	.drop_not_locked
 
;-------------------------------------------------
; maybe we are the receiver in the uni-xfer then..
 
  .not_sender:
; - The amount of data in the segment is greater than 0 (data count is in ecx)
 
; - 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).
 
;;; TODO
 
	jnz	.not_uni_xfer
 
; Complete processing of received data
 
	DEBUGF	1,"header prediction: we are receiver\nreceiving %u bytes of data\n", ecx
 
	add	[ebx + TCP_SOCKET.RCV_NXT], ecx 	; Update sequence number with number of bytes we have copied
 
	add	esi, edx
	lea	eax, [ebx + STREAM_SOCKET.rcv]
	call	SOCKET_ring_write			; Add the data to the socket buffer
 
	mov	eax, ebx
	call	SOCKET_notify_owner
 
	or	[ebx + TCP_SOCKET.t_flags], TF_DELACK	; Set delayed ack flag
 
	jmp	.drop
 
 
 
 
 
 
;--------------------------------------------------
; Header prediction failed, do it the slow way
 
  .not_uni_xfer:
 
	DEBUGF	1,"Header prediction failed\n"
 
; Calculate receive window size
 
;;;; TODO: 444
 
	cmp	[ebx + TCP_SOCKET.t_state], TCB_LISTEN
	je	.LISTEN
 
	cmp	[ebx + TCP_SOCKET.t_state], TCB_SYN_SENT
	je	.SYN_SENT
 
	jmp	.NOT_LISTEN_OR_SYN_SENT
 
 
 
;-------------
; Passive Open
 
align 4
.LISTEN:
 
	DEBUGF	1,"TCP state: listen\n"
 
	test	[edx + TCP_segment.Flags], TH_RST	;;; TODO: kill new socket on error
	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
 
	add	[TCP_sequence_num], 64000
 
	push	[edx + TCP_segment.SourcePort]
	pop	[eax + TCP_SOCKET.RemotePort]
 
	push	[edx + TCP_segment.SequenceNumber]
	pop	[eax + TCP_SOCKET.IRS]
 
	push	[eax + TCP_SOCKET.ISS]
	pop	[eax + TCP_SOCKET.SND_NXT]
 
	TCP_sendseqinit eax
	TCP_rcvseqinit eax
 
	mov	[eax + TCP_SOCKET.t_state], TCB_SYN_RECEIVED
	mov	[eax + TCP_SOCKET.t_flags], TF_ACKNOW
	mov	[eax + TCP_SOCKET.timer_keepalive], TCP_time_keep_interval  ;;;; macro
 
	add	eax, STREAM_SOCKET.snd
	call	SOCKET_ring_create
 
	add	eax, STREAM_SOCKET.rcv - STREAM_SOCKET.snd
	call	SOCKET_ring_create
 
	lea	ebx, [eax - STREAM_SOCKET.rcv]
	mov	[ebx + SOCKET.lock], 0
 
	jmp	.trim_then_step6
 
 
 
 
 
 
 
 
;------------
; Active Open
 
align 4
.SYN_SENT:
 
	DEBUGF	1,"TCP state: syn_sent\n"
 
	test	[edx + TCP_segment.Flags], TH_ACK
	jz	@f
 
	mov	eax, [edx + TCP_segment.AckNumber]
	cmp	eax, [ebx + TCP_SOCKET.ISS]
	jle	.drop_with_reset
 
	cmp	eax, [ebx + TCP_SOCKET.SND_MAX]
	jg	.drop_with_reset
       @@:
 
	test	[edx + TCP_segment.Flags], TH_RST
	jz	@f
 
	test	[edx + TCP_segment.Flags], TH_ACK
	jz	.drop
 
	mov	eax, ebx
	mov	ebx, ECONNREFUSED
	call	TCP_drop
 
	jmp	.drop
       @@:
 
	test	[edx + TCP_segment.Flags], TH_SYN
	jz	.drop
 
; at this point, segment seems to be valid
 
	test	[edx + TCP_segment.Flags], TH_ACK
	jz	.no_syn_ack
 
; now, process received SYN in response to an active open
 
	mov	eax, [edx + TCP_segment.AckNumber]
	mov	[ebx + TCP_SOCKET.SND_UNA], eax
	cmp	eax, [ebx + TCP_SOCKET.SND_NXT]
	jle	@f
	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]
 
	TCP_rcvseqinit ebx
 
	or	[ebx + TCP_SOCKET.t_flags], TF_ACKNOW
 
	mov	eax, [ebx + TCP_SOCKET.SND_UNA]
	cmp	eax, [ebx + TCP_SOCKET.ISS]
	jle	.simultaneous_open
 
	test	[edx + TCP_segment.Flags], TH_ACK
	jz	.simultaneous_open
 
	DEBUGF	1,"TCP: active open\n"
 
;;; TODO: update stats
 
; set socket state to connected
 
	mov	[ebx + SOCKET.state],1	;;;; FIXME
 
	mov	[ebx + TCP_SOCKET.t_state], TCB_ESTABLISHED
 
;;; TODO: check if we should scale the connection (567-572)
;;; TODO: update RTT estimators
 
	jmp	.trim_then_step6
 
  .simultaneous_open:
 
	DEBUGF	1,"TCP: simultaneous open\n"
; We have received a syn but no ACK, so we are having a simultaneous open..
	mov	[ebx + TCP_SOCKET.t_state], TCB_SYN_RECEIVED
 
 
 
 
 
 
 
;-------------------------------------
; Common processing for receipt of SYN
 
  .trim_then_step6:
 
	inc	[edx + TCP_segment.SequenceNumber]
 
;;; TODO: Drop any received data that follows receive window (590)
 
	mov	eax, [edx + TCP_segment.SequenceNumber]
	mov	[ebx + TCP_SOCKET.RCV_UP], eax
	dec	eax
	mov	[ebx + TCP_SOCKET.SND_WL1], eax
 
	jmp	.ack_processed
 
 
 
 
 
 
 
 
  .NOT_LISTEN_OR_SYN_SENT:
 
	DEBUGF	1,"Slow TCP input: not listen or syn_sent state\n"
 
;--------------------------------------------
; Protection Against Wrapped Sequence Numbers
 
; First, check if timestamp is present
 
;;;; TODO 602
 
; Then, check if at least some bytes of data are within window
 
;;;; TODO
 
 
 
 
 
 
 
 
;----------------------------
; trim any data not in window
 
; check for duplicate data at beginning of segment
 
	mov	eax, [ebx + TCP_SOCKET.RCV_NXT]
	sub	eax, [edx + TCP_segment.SequenceNumber]
	jle	.no_duplicate
 
	DEBUGF	1,"Uh oh.. %x bytes of duplicate data!\n", eax
 
	test	[edx + TCP_segment.Flags], TH_SYN
	jz	.no_dup_syn
 
; remove duplicate syn
 
	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_dup_syn
       @@:
 
	and	[edx + TCP_segment.Flags], not (TH_URG)
	dec	eax
	jz	.no_duplicate
  .no_dup_syn:
 
	DEBUGF	1,"Going to drop %u out of %u bytes\n", eax, ecx
 
; eax holds number of bytes to drop
 
; Check for entire duplicate packet
 
	cmp	eax, ecx
	jge	.duplicate
 
;;; TODO: apply figure 28.30
 
; 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
	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
 
;-------------------------------------
; 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:
 
	DEBUGF	1,"Duplicate received\n"
 
;----------------------------------------
; Update statistics for duplicate packets
 
;;; TODO
 
	jmp	.drop	       ;;; 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
	jg	@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
 
	DEBUGF	1,"Got an RST flag"
 
	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:
 
	DEBUGF	1,"Connection refused"
 
;;; TODO: debug info
 
	jmp	.close
 
  .econnreset:
 
	DEBUGF	1,"Connection reset"
 
;;; TODO: debug info
 
  .close:
 
	DEBUGF	1,"Closing connection"
 
;;; update stats
 
  .rst_close:
 
	DEBUGF	1,"Closing with reset\n"
 
;;; Close the socket
 
	jmp	.drop
 
 
 
 
 
 
 
  .rst_skip:
 
 
;--------------------------------------
; handle SYN-full and ACK-less segments
 
	test	[edx + TCP_segment.Flags], TH_SYN
	jz	@f
 
	mov	ebx, ECONNRESET
	call	TCP_drop
 
	jmp	.drop_with_reset
 
	test	[edx + TCP_segment.Flags], TH_ACK
	jz	.drop
      @@:
 
 
 
 
 
 
 
;---------------
; ACK processing
 
	cmp	[ebx + TCP_SOCKET.t_state], TCB_SYN_RECEIVED
	jnz	.no_syn_rcv
 
	DEBUGF	1,"TCP state = syn received\n"
 
	;;;;;  801-815
 
  .no_syn_rcv:
 
; check for duplicate ACK
 
	mov	eax, [edx + TCP_segment.AckNumber]
	cmp	eax, [ebx + TCP_SOCKET.SND_UNA]
	jg	.not_dup_ack
 
	test	ecx, ecx
	jnz	.reset_dupacks
 
	mov	eax, dword [edx + TCP_segment.Window]
	cmp	eax, [ebx + TCP_SOCKET.SND_WND]
	jne	.reset_dupacks
 
	DEBUGF	1,"Processing a duplicate ACK..\n"
 
	cmp	[ebx + TCP_SOCKET.timer_retransmission], 10000 ;;;;
	jg	@f
 
	mov	eax, [edx + TCP_segment.AckNumber]
	cmp	eax, [ebx + TCP_SOCKET.SND_UNA]
	je	.dup_ack
 
       @@:
	mov	[ebx + TCP_SOCKET.t_dupacks], 0
	jmp	.not_dup_ack
 
  .dup_ack:
	inc	[ebx + TCP_SOCKET.t_dupacks]
	cmp	[ebx + TCP_SOCKET.t_dupacks], TCP_re_xmit_thresh
	jne	.no_re_xmit
 
	push	[ebx + TCP_SOCKET.SND_NXT]		; >>>>
 
	mov	eax, [ebx + TCP_SOCKET.SND_WND]
	cmp	eax, [ebx + TCP_SOCKET.SND_CWND]
	cmovg	eax, [ebx + TCP_SOCKET.SND_CWND]
	shr	eax, 1
	push	edx
	xor	edx, edx
	div	[ebx + TCP_SOCKET.t_maxseg]
	cmp	eax, 2
	jge	@f
	mov	ax, 2
       @@:
	mul	[ebx + TCP_SOCKET.t_maxseg]
	pop	edx
	mov	[ebx + TCP_SOCKET.SND_SSTHRESH], eax
 
	mov	[ebx + TCP_SOCKET.timer_retransmission], 0	; turn off retransmission timer
	mov	[ebx + TCP_SOCKET.t_rtt], 0
	mov	eax, [edx + TCP_segment.AckNumber]
	mov	[ebx + TCP_SOCKET.SND_NXT], eax
	mov	eax, [ebx + TCP_SOCKET.t_maxseg]
	mov	[ebx + TCP_SOCKET.SND_CWND], eax
 
	mov	eax, ebx
	call	TCP_output					; retransmit missing segment
 
	push	edx
	xor	edx, edx
	mov	eax, [ebx + TCP_SOCKET.t_maxseg]
	mul	[ebx + TCP_SOCKET.t_dupacks]
	pop	edx
	add	eax, [ebx + TCP_SOCKET.SND_SSTHRESH]
	mov	[ebx + TCP_SOCKET.SND_CWND], eax
 
	pop	eax					; <<<<
	cmp	eax, [ebx + TCP_SOCKET.SND_NXT]
	jl	@f
	mov	[ebx + TCP_SOCKET.SND_NXT], eax
       @@:
 
	jmp	.drop
 
 
  .no_re_xmit:
	jle	.not_dup_ack
 
	DEBUGF	1,"Increasing congestion window\n"
 
	mov	eax, [ebx + TCP_SOCKET.t_maxseg]
	add	[ebx + TCP_SOCKET.SND_CWND], eax
 
	mov	eax, ebx
	call	TCP_output
 
	jmp	.drop
 
 
 
 
 
 
  .not_dup_ack:
 
;-------------------------------------------------
; If the congestion window was inflated to account
; for the other side's cached packets, retract it
 
	mov	eax, [ebx + TCP_SOCKET.SND_SSTHRESH]
	cmp	eax, [ebx + TCP_SOCKET.SND_CWND]
	jg	@f
	cmp	[ebx + TCP_SOCKET.t_dupacks], TCP_re_xmit_thresh
	jle	@f
	mov	[ebx + TCP_SOCKET.SND_CWND], eax
       @@:
 
	mov	[ebx + TCP_SOCKET.t_dupacks], 0
 
	mov	eax, [edx + TCP_segment.AckNumber]
	cmp	eax, [ebx + TCP_SOCKET.SND_MAX]
	jle	@f
 
	;;; TODO: update stats
	jmp	.drop_after_ack
 
       @@:
 
	mov	edi, [edx + TCP_segment.AckNumber]
	sub	edi, [ebx + TCP_SOCKET.SND_UNA] 	; now we got the number of acked bytes in esi
 
	;;; TODO: update stats
 
 
	DEBUGF	1,"We have an acceptable ACK of %x bytes\n", esi
 
 
 
 
 
 
;------------------------------------------
; RTT measurements and retransmission timer
 
	;;;;; 912 - 926
 
	mov	[ebx + TCP_SOCKET.timer_retransmission], 0
 
	mov	eax, [ebx + TCP_SOCKET.SND_MAX]
	cmp	eax, [edx + TCP_segment.AckNumber]
	je	.all_outstanding
	mov	[ebx + TCP_SOCKET.timer_retransmission], 120 ;;;; TODO: correct this value (use a macro for it)
  .all_outstanding:
 
 
 
 
 
 
 
;-------------------------------------------
; Open congestion window in response to ACKs
 
	mov	esi, [ebx + TCP_SOCKET.SND_CWND]
	mov	eax, [ebx + TCP_SOCKET.t_maxseg]
 
	cmp	esi, [ebx + TCP_SOCKET.SND_SSTHRESH]
	jle	@f
	push	edx
	push	eax
	mul	eax
	div	esi
	pop	edx
	shr	edx, 3
	add	eax, edx
	pop	edx
       @@:
 
	add	esi, eax
 
	push	ecx
	mov	cl, [ebx + TCP_SOCKET.SND_SCALE]
	mov	eax, TCP_max_win
	shl	eax, cl
	pop	ecx
 
	cmp	esi, eax
	cmovg	esi, eax
	mov	[ebx + TCP_SOCKET.SND_CWND], esi
 
 
 
 
 
 
 
;------------------------------------------
; Remove acknowledged data from send buffer
 
	push	ecx edx ebx
	mov	ecx, edi
	lea	eax, [ebx + STREAM_SOCKET.snd]
	call	SOCKET_ring_free
	pop	ebx
	sub	[ebx + TCP_SOCKET.SND_WND], ecx
	pop	edx ecx
 
; Wake up process waiting on send buffer
 
	mov	eax, ebx
	call	SOCKET_notify_owner
 
; Update TCB
 
	mov	eax, [edx + TCP_segment.AckNumber]
	mov	[ebx + TCP_SOCKET.SND_UNA], eax
 
	cmp	eax, [ebx + TCP_SOCKET.SND_NXT]
	jl	@f
	mov	[ebx + TCP_SOCKET.SND_NXT], eax
       @@:
 
 
	;; TODO: use zero flag as 'ourfinisacked'
 
 
 
 
; General ACK handling complete
; Now do the state-specific ones
 
	mov	eax, [ebx + TCP_SOCKET.t_state]
	jmp	dword [eax*4 + .ACK_sw_list]
 
  .ACK_sw_list:
	dd	.ack_processed	;TCB_CLOSED
	dd	.ack_processed	;TCB_LISTEN
	dd	.ack_processed	;TCB_SYN_SENT
	dd	.ack_processed	;TCB_SYN_RECEIVED
	dd	.ack_processed	;TCB_ESTABLISHED
	dd	.ack_processed	;TCB_CLOSE_WAIT
	dd	.ack_fw1	;TCB_FIN_WAIT_1
	dd	.ack_c		;TCB_CLOSING
	dd	.ack_la 	;TCB_LAST_ACK
	dd	.ack_processed	;TCB_FIN_WAIT_2
	dd	.ack_tw 	;TCB_TIMED_WAIT
 
 
  .ack_fw1:
	jz	.ack_processed
 
	test	[ebx + SOCKET.state], SS_CANTRCVMORE
	jnz	@f
	mov	eax, ebx
	call	SOCKET_is_disconnected
;;;        mov     [ebx + TCP_SOCKET.timer_timed_wait], TCP_time_max_idle
       @@:
 
	mov	[ebx + TCP_SOCKET.t_state], TCB_FIN_WAIT_2
	jmp	.ack_processed
 
 
  .ack_c:
	jz	.ack_processed
 
	mov	[ebx + TCP_SOCKET.t_state], TCB_TIMED_WAIT
	mov	eax, ebx
	call	TCP_cancel_timers
	mov	[ebx + TCP_SOCKET.timer_timed_wait], 2 * TCP_time_MSL
	mov	eax, ebx
	call	SOCKET_is_disconnected
	jmp	.ack_processed
 
 
  .ack_la:
	jz	.ack_processed
 
 
	mov	eax, ebx
	call	TCP_close
	jmp	.drop
 
 
  .ack_tw:
	mov	[ebx + TCP_SOCKET.timer_timed_wait], 2 * TCP_time_MSL
	jmp	.drop_after_ack
 
 
 
 
 
 
 
  .reset_dupacks:		; We got a new ACK, reset duplicate ACK counter
 
	mov	[ebx + TCP_SOCKET.t_dupacks], 0
 
  .ack_processed:	; (step 6)
 
	DEBUGF	1,"ACK processed\n"
 
;----------------------------------------------
; check if we need to 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]
	jl	.update_window
	jg	@f
 
	mov	eax, [ebx + TCP_SOCKET.SND_WL2]
	cmp	eax, [edx + TCP_segment.AckNumber]
	jl	.update_window
	jg	.no_window_update
       @@:
 
	mov	eax, [ebx + TCP_SOCKET.SND_WL2]
	cmp	eax, [edx + TCP_segment.AckNumber]
	jne	.no_window_update
 
	movzx	eax, [edx + TCP_segment.Window]
	cmp	eax, [ebx + TCP_SOCKET.SND_WND]
	jle	.no_window_update
 
  .update_window:
 
	DEBUGF	1,"Updating window\n"
 
; 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, dword [edx + TCP_segment.Window]
	cmp	eax, [ebx + TCP_SOCKET.max_sndwnd]
	jle	@f
	mov	[ebx + TCP_SOCKET.max_sndwnd], eax
       @@:
	mov	[ebx + TCP_SOCKET.SND_WND], eax
 
	push	[edx + TCP_segment.SequenceNumber]
	pop	[ebx + TCP_SOCKET.SND_WL1]
 
	push	[edx + TCP_segment.AckNumber]
	pop	[ebx + TCP_SOCKET.SND_WL2]
 
	;;; 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 + STREAM_SOCKET.rcv + RING_BUFFER.size]
	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
 
	;;; TODO (1051-1093)
 
 
 
 
 
 
 
 
;--------------------------------
; process the data in the segment
 
  .do_data:
 
	DEBUGF	1,"TCP: do data (%u)\n", ecx
 
	test	[edx + TCP_segment.Flags], TH_FIN
	jnz	.process_fin
 
	cmp	[ebx + TCP_SOCKET.t_state], TCB_FIN_WAIT_1
	jge	.dont_do_data
 
	test	ecx, ecx
	jz	.final_processing
 
	DEBUGF	1,"Processing data in segment\n"
 
;; TODO: check if data is in sequence !
 
	movzx	eax, [edx + TCP_segment.DataOffset]		;;; todo: remember this in.. edi ?
	and	eax, 0xf0
	shr	al, 2
 
	lea	esi, [edx + eax]
 
	or	[ebx + TCP_SOCKET.t_flags], TF_DELACK
	add	[ebx + TCP_SOCKET.RCV_NXT], ecx
 
	lea	eax, [ebx + STREAM_SOCKET.rcv]
	call	SOCKET_ring_write
 
	mov	eax, ebx
	call	SOCKET_notify_owner
 
	jmp	.final_processing
 
 
  .dont_do_data:
 
 
 
 
 
 
 
;---------------
; FIN processing
 
  .process_fin:
 
	DEBUGF	1,"Processing FIN\n"
 
	cmp	[ebx + TCP_SOCKET.t_state], TCB_CLOSE_WAIT
	je	.not_first_fin
	cmp	[ebx + TCP_SOCKET.t_state], TCB_CLOSING
	je	.not_first_fin
	cmp	[ebx + TCP_SOCKET.t_state], TCB_FIN_WAIT_2
	je	.not_first_fin
 
	DEBUGF	1,"First FIN for this connection\n"
 
	mov	eax, ebx
	call	SOCKET_cant_recv_more
 
	mov	[ebx + TCP_SOCKET.t_flags], TF_ACKNOW
	inc	[ebx + TCP_SOCKET.RCV_NXT]
 
  .not_first_fin:
	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	.fin_syn_est	;TCB_SYN_RECEIVED
	dd	.fin_syn_est	;TCB_ESTABLISHED
	dd	.no_fin 	;TCB_CLOSE_WAIT
	dd	.fin_wait1	;TCB_FIN_WAIT_1
	dd	.no_fin 	;TCB_CLOSING
	dd	.no_fin 	;TCB_LAST_ACK
	dd	.fin_wait2	;TCB_FIN_WAIT_2
	dd	.fin_timed	;TCB_TIMED_WAIT
 
 
 
  .fin_syn_est:
 
	mov	[ebx + TCP_SOCKET.t_state], TCB_CLOSE_WAIT
	jmp	.no_fin
 
  .fin_wait1:
 
	mov	[ebx + TCP_SOCKET.t_state], TCB_CLOSING
	jmp	.no_fin
 
  .fin_wait2:
 
	mov	[ebx + TCP_SOCKET.t_state], TCB_TIMED_WAIT
	mov	eax, ebx
	call	TCP_cancel_timers
	mov	[ebx + TCP_SOCKET.timer_timed_wait], 2 * TCP_time_MSL
	call	SOCKET_is_disconnected
	jmp	.no_fin
 
 
  .fin_timed:
	mov	[ebx + TCP_SOCKET.timer_timed_wait], 2 * TCP_time_MSL
	jmp	.no_fin
 
  .no_fin:
 
 
 
 
 
 
 
 
;-----------------
; Final processing
 
  .final_processing:
 
	DEBUGF	1,"Final processing\n"
 
	;;; if debug enabled, output packet
 
	;test    needoutput, needoutput
	;jz      .dumpit
 
	test	[ebx + TCP_SOCKET.t_flags], TF_ACKNOW
	jz	.dumpit
 
	DEBUGF	1,"ACK now!\n"
 
	push	ebx
	mov	eax, ebx
	call	TCP_output
	pop	ebx
 
  .dumpit:
 
	mov	[ebx + SOCKET.lock], 0
 
	call	kernel_free
	add	esp, 4
	ret
 
 
 
 
 
 
 
;------------------------------------------
; Generate an ACK, droping incoming segment
 
align 4
.drop_after_ack:
 
	DEBUGF	1,"Drop after ACK\n"
 
	test	[edx + TCP_segment.Flags], TH_RST
	jnz	.drop
 
	and	[ebx + TCP_SOCKET.t_flags], TF_ACKNOW
 
	mov	[ebx + SOCKET.lock], 0
 
	push	ebx
	mov	eax, ebx
	call	TCP_output
	pop	ebx
 
	call	kernel_free
	add	esp, 4
	ret
 
 
 
 
 
 
 
 
;-------------------------------------------
; Generate an RST, dropping incoming segment
 
align 4
.drop_with_reset:
 
	mov	[ebx + SOCKET.lock], 0
 
.drop_with_reset_not_locked:
 
	DEBUGF	1,"Drop with reset\n"
 
	test	[edx + TCP_segment.Flags], TH_RST
	jnz	.drop
 
	;;; if its a multicast/broadcast, also drop
 
	test	[edx + TCP_segment.Flags], TH_ACK
	jnz	.respond_ack
 
	test	[edx + TCP_segment.Flags], TH_SYN
	jnz	.respond_syn
 
	call	kernel_free
	add	esp, 4
	ret
 
  .respond_ack:
 
	mov	dl, TH_RST
 
	push	ebx
	call	TCP_respond_segment
	pop	ebx
 
	jmp	.destroy_new_socket
 
 
  .respond_syn:
 
	mov	dl, TH_RST + TH_ACK
 
	push	ebx
	call	TCP_respond_socket
	pop	ebx
 
	jmp	.destroy_new_socket
 
 
 
 
 
 
 
;-----
; Drop
 
align 4
.drop:
 
	mov	[ebx + SOCKET.lock], 0
 
.drop_not_locked:
 
	DEBUGF	1,"Dropping packet\n"
 
	;;;; If debugging options are enabled, output the packet somwhere
 
  .destroy_new_socket:
 
	;;;; kill the newly created socket
 
	call	kernel_free
	add	esp, 4
	ret
>
>
>
>

Rev 1773	Rev 1774
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;; Part of the tcp/ip network stack for KolibriOS ;;	6	;; Part of the tcp/ip network stack for KolibriOS ;;
7	;; ;;	7	;; ;;
8	;; Written by hidnplayr@kolibrios.org ;;	8	;; Written by hidnplayr@kolibrios.org ;;
9	;; ;;	9	;; ;;
10	;; Based on the code of 4.4BSD ;;	10	;; Based on the code of 4.4BSD ;;
11	;; ;;	11	;; ;;
12	;; GNU GENERAL PUBLIC LICENSE ;;	12	;; GNU GENERAL PUBLIC LICENSE ;;
13	;; Version 2, June 1991 ;;	13	;; Version 2, June 1991 ;;
14	;; ;;	14	;; ;;
15	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	15	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
16		16
17	$Revision: 1773 $	17	$Revision: 1774 $
18		18
19	;-----------------------------------------------------------------	19	;-----------------------------------------------------------------
20	;	20	;
21	; TCP_input:	21	; TCP_input:
22	;	22	;
23	; IN: [esp] = ptr to buffer	23	; IN: [esp] = ptr to buffer
24	; [esp+4] = buffer size	24	; [esp+4] = buffer size
25	; ebx = ptr to device struct	25	; ebx = ptr to device struct
26	; ecx = segment size	26	; ecx = segment size
27	; edx = ptr to TCP segment	27	; edx = ptr to TCP segment
28	;	28	;
29	; esi = ipv4 source address	29	; esi = ipv4 source address
30	; edi = ipv4 dest address	30	; edi = ipv4 dest address
31	;	31	;
32	; OUT: /	32	; OUT: /
33	;	33	;
34	;-----------------------------------------------------------------	34	;-----------------------------------------------------------------
35	align 4	35	align 4
36	TCP_input:	36	TCP_input:
37		37
38	DEBUGF 1,"TCP_input size=%u ", ecx	38	DEBUGF 1,"TCP_input size=%u ", ecx
39	; 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.	39	; 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.
40		40
41	movzx eax, [edx + TCP_segment.DataOffset]	41	movzx eax, [edx + TCP_segment.DataOffset]
42	and eax, 0xf0	42	and eax, 0xf0
43	shr al, 2	43	shr al, 2
44		44
45	DEBUGF 1,"headersize=%u\n", eax	45	DEBUGF 1,"headersize=%u\n", eax
46		46
47	cmp eax, 20	47	cmp eax, 20
48	jl .drop_not_locked	48	jl .drop_not_locked
49		49
50	;-------------------------------	50	;-------------------------------
51	; Now, re-calculate the checksum	51	; Now, re-calculate the checksum
52		52
53	push eax ecx edx	53	push eax ecx edx
54	pushw [edx + TCP_segment.Checksum]	54	pushw [edx + TCP_segment.Checksum]
55	mov [edx + TCP_segment.Checksum], 0	55	mov [edx + TCP_segment.Checksum], 0
56	push esi edi	56	push esi edi
57	mov esi, edx	57	mov esi, edx
58	TCP_checksum (esp), (esp+4)	58	TCP_checksum (esp), (esp+4)
59	pop esi edi ; yes, swap them (we dont need dest addr)	59	pop esi edi ; yes, swap them (we dont need dest addr)
60	pop cx ; previous checksum	60	pop cx ; previous checksum
61	cmp cx, dx	61	cmp cx, dx
62	pop edx ecx esi	62	pop edx ecx esi
63	jnz .drop_not_locked	63	jnz .drop_not_locked
64		64
65	DEBUGF 1,"Checksum is correct\n"	65	DEBUGF 1,"Checksum is correct\n"
66		66
67	sub ecx, esi ; update packet size	67	sub ecx, esi ; update packet size
68	jl .drop_not_locked	68	jl .drop_not_locked
69	DEBUGF 1,"we got %u bytes of data\n", ecx	69	DEBUGF 1,"we got %u bytes of data\n", ecx
70		70
71	;-----------------------------------------------------------------------------------------	71	;-----------------------------------------------------------------------------------------
72	; Check if this packet has a timestamp option (We do it here so we can process it quickly)	72	; Check if this packet has a timestamp option (We do it here so we can process it quickly)
73		73
74	cmp esi, 20 + 12 ; Timestamp option is 12 bytes	74	cmp esi, 20 + 12 ; Timestamp option is 12 bytes
75	jl .no_timestamp	75	jl .no_timestamp
76	je .is_ok	76	je .is_ok
77		77
78	cmp byte [edx + TCP_segment.Data + 12], TCP_OPT_EOL ; end of option list	78	cmp byte [edx + TCP_segment.Data + 12], TCP_OPT_EOL ; end of option list
79	jne .no_timestamp	79	jne .no_timestamp
80		80
81	.is_ok:	81	.is_ok:
82	test [edx + TCP_segment.Flags], TH_SYN ; SYN flag must not be set	82	test [edx + TCP_segment.Flags], TH_SYN ; SYN flag must not be set
83	jnz .no_timestamp	83	jnz .no_timestamp
84		84
85	cmp dword [edx + TCP_segment.Data], 0x0101080a ; Timestamp header	85	cmp dword [edx + TCP_segment.Data], 0x0101080a ; Timestamp header
86	jne .no_timestamp	86	jne .no_timestamp
87		87
88	DEBUGF 1,"timestamp ok\n"	88	DEBUGF 1,"timestamp ok\n"
89		89
90	; TODO: Parse the option	90	; TODO: Parse the option
91	; TODO: Set a Bit in the TCP to tell all options are parsed	91	; TODO: Set a Bit in the TCP to tell all options are parsed
92		92
93	.no_timestamp:	93	.no_timestamp:
94		94
95	;-------------------------------------------	95	;-------------------------------------------
96	; Convert Big-endian values to little endian	96	; Convert Big-endian values to little endian
97		97
98	ntohd [edx + TCP_segment.SequenceNumber]	98	ntohd [edx + TCP_segment.SequenceNumber]
99	ntohd [edx + TCP_segment.AckNumber]	99	ntohd [edx + TCP_segment.AckNumber]
100		100
101	ntohw [edx + TCP_segment.Window]	101	ntohw [edx + TCP_segment.Window]
102	ntohw [edx + TCP_segment.UrgentPointer]	102	ntohw [edx + TCP_segment.UrgentPointer]
103	ntohw [edx + TCP_segment.SourcePort]	103	ntohw [edx + TCP_segment.SourcePort]
104	ntohw [edx + TCP_segment.DestinationPort]	104	ntohw [edx + TCP_segment.DestinationPort]
105		105
106	;------------------------------------------------------------	106	;------------------------------------------------------------
107	; Next thing to do is find the TCB (thus, the socket pointer)	107	; Next thing to do is find the TCB (thus, the socket pointer)
108		108
109	; IP Packet TCP Destination Port = local Port	109	; IP Packet TCP Destination Port = local Port
110	; (IP Packet SenderAddress = Remote IP) OR (Remote IP = 0)	110	; (IP Packet SenderAddress = Remote IP) OR (Remote IP = 0)
111	; (IP Packet TCP Source Port = remote Port) OR (remote Port = 0)	111	; (IP Packet TCP Source Port = remote Port) OR (remote Port = 0)
112		112
113	mov ebx, net_sockets	113	mov ebx, net_sockets
114		114
115	.socket_loop:	115	.socket_loop:
116	mov ebx, [ebx + SOCKET.NextPtr]	116	mov ebx, [ebx + SOCKET.NextPtr]
117	or ebx, ebx	117	or ebx, ebx
118	jz .drop_with_reset_not_locked	118	jz .drop_with_reset_not_locked
119		119
120	cmp [ebx + SOCKET.Domain], AF_INET4	120	cmp [ebx + SOCKET.Domain], AF_INET4
121	jne .socket_loop	121	jne .socket_loop
122		122
123	cmp [ebx + SOCKET.Protocol], IP_PROTO_TCP	123	cmp [ebx + SOCKET.Protocol], IP_PROTO_TCP
124	jne .socket_loop	124	jne .socket_loop
125		125
126	mov ax, [edx + TCP_segment.DestinationPort]	126	mov ax, [edx + TCP_segment.DestinationPort]
127	cmp [ebx + TCP_SOCKET.LocalPort], ax	127	cmp [ebx + TCP_SOCKET.LocalPort], ax
128	jne .socket_loop	128	jne .socket_loop
129		129
130	mov eax, [ebx + IP_SOCKET.RemoteIP]	130	mov eax, [ebx + IP_SOCKET.RemoteIP]
131	cmp eax, edi ; edi is source ip from packet	131	cmp eax, edi ; edi is source ip from packet
132	je @f	132	je @f
133	test eax, eax	133	test eax, eax
134	jnz .socket_loop	134	jnz .socket_loop
135	@@:	135	@@:
136		136
137	mov ax, [ebx + TCP_SOCKET.RemotePort]	137	mov ax, [ebx + TCP_SOCKET.RemotePort]
138	cmp [edx + TCP_segment.SourcePort] , ax	138	cmp [edx + TCP_segment.SourcePort] , ax
139	je .found_socket	139	je .found_socket
140	test ax, ax	140	test ax, ax
141	jnz .socket_loop	141	jnz .socket_loop
142	.found_socket:	142	.found_socket:
143	DEBUGF 1,"Socket ptr: %x\n", ebx	143	DEBUGF 1,"Socket ptr: %x\n", ebx
144		144
145	; ebx now contains the pointer to the socket	145	; ebx now contains the pointer to the socket
146		146
147	;----------------------------	147	;----------------------------
148	; Check if socket isnt closed	148	; Check if socket isnt closed
149		149
150	cmp [ebx + TCP_SOCKET.t_state], TCB_CLOSED	150	cmp [ebx + TCP_SOCKET.t_state], TCB_CLOSED
151	je .drop_not_locked	151	je .drop_not_locked
152		152
153	;----------------	153	;----------------
154	; Lock the socket	154	; Lock the socket
155		155
156	add ebx, SOCKET.lock	156	add ebx, SOCKET.lock
157	DEBUGF 1,"lock: %x\n", [ebx]	157	DEBUGF 1,"lock: %x\n", [ebx]
158	call wait_mutex	158	call wait_mutex
159	sub ebx, SOCKET.lock	159	sub ebx, SOCKET.lock
160		160
161	DEBUGF 1,"Socket locked\n"	161	DEBUGF 1,"Socket locked\n"
162		162
163	;---------------------------------------	163	;---------------------------------------
164	; unscale the window into a 32 bit value	164	; unscale the window into a 32 bit value
165		165
166	movzx eax, [edx + TCP_segment.Window]	166	movzx eax, [edx + TCP_segment.Window]
167	push ecx	167	push ecx
168	mov cl, [ebx + TCP_SOCKET.SND_SCALE]	168	mov cl, [ebx + TCP_SOCKET.SND_SCALE]
169	shl eax, cl	169	shl eax, cl
170	mov dword [edx + TCP_segment.Window], eax ; word after window is checksum, we dont need checksum anymore	170	mov dword [edx + TCP_segment.Window], eax ; word after window is checksum, we dont need checksum anymore
171	pop ecx	171	pop ecx
172		172
173	;-----------------------------------	173	;-----------------------------------
174	; Is this socket a listening socket?	174	; Is this socket a listening socket?
175		175
176	test [ebx + SOCKET.options], SO_ACCEPTCON	176	test [ebx + SOCKET.options], SO_ACCEPTCON
177	jz .no_listening_socket	177	jz .no_listening_socket
178		178
179	call SOCKET_fork	179	call SOCKET_fork
180	jz .drop	180	jz .drop
181		181
182	push [edx + TCP_segment.DestinationPort]	182	push [edx + TCP_segment.DestinationPort]
183	pop [eax + TCP_SOCKET.LocalPort]	183	pop [eax + TCP_SOCKET.LocalPort]
184		184
185	push [edx - IPv4_Packet.DataOrOptional + IPv4_Packet.DestinationAddress] ;;; FIXME	185	push [edx - IPv4_Packet.DataOrOptional + IPv4_Packet.DestinationAddress] ;;; FIXME
186	pop [eax + IP_SOCKET.LocalIP]	186	pop [eax + IP_SOCKET.LocalIP]
187		187
188	push [edx - IPv4_Packet.DataOrOptional + IPv4_Packet.SourceAddress] ;;; FIXME	188	push [edx - IPv4_Packet.DataOrOptional + IPv4_Packet.SourceAddress] ;;; FIXME
189	pop [eax + IP_SOCKET.RemoteIP]	189	pop [eax + IP_SOCKET.RemoteIP]
190		190
191	mov [eax + TCP_SOCKET.t_state], TCB_LISTEN	191	mov [eax + TCP_SOCKET.t_state], TCB_LISTEN
192		192
193	jmp .not_uni_xfer	193	jmp .not_uni_xfer
194		194
195	.no_listening_socket:	195	.no_listening_socket:
196		196
197	;-------------------------------------	197	;-------------------------------------
198	; Reset idle timer and keepalive timer	198	; Reset idle timer and keepalive timer
199		199
200	mov [ebx + TCP_SOCKET.t_idle], 0	200	mov [ebx + TCP_SOCKET.t_idle], 0
201	mov [ebx + TCP_SOCKET.timer_keepalive], TCP_time_keep_interval	201	mov [ebx + TCP_SOCKET.timer_keepalive], TCP_time_keep_interval
202		202
203	;--------------------	203	;--------------------
204	; Process TCP options	204	; Process TCP options
205		205
206	cmp esi, 20 ; esi is headersize	206	cmp esi, 20 ; esi is headersize
207	je .no_options	207	je .no_options
208		208
209	DEBUGF 1,"Segment has options\n"	209	DEBUGF 1,"Segment has options\n"
210		210
211	cmp [ebx + TCP_SOCKET.t_state], TCB_LISTEN ; no options when in listen state	211	cmp [ebx + TCP_SOCKET.t_state], TCB_LISTEN ; no options when in listen state
212	jz .not_uni_xfer ; also no header prediction	212	jz .not_uni_xfer ; also no header prediction
213		213
214	lea edi, [edx + TCP_segment.Data]	214	lea edi, [edx + TCP_segment.Data]
215	lea eax, [edx + esi]	215	lea eax, [edx + esi]
216		216
217	.opt_loop:	217	.opt_loop:
218	cmp edi, eax	218	cmp edi, eax
219	jge .no_options	219	jge .no_options
220		220
221	cmp byte [edi], TCP_OPT_EOL ; end of option list?	221	cmp byte [edi], TCP_OPT_EOL ; end of option list?
222	jz .no_options	222	jz .no_options
223		223
224	cmp byte [edi], TCP_OPT_NOP ; nop ?	224	cmp byte [edi], TCP_OPT_NOP ; nop ?
225	jz .opt_nop	225	jz .opt_nop
226		226
227	cmp byte [edi], TCP_OPT_MAXSEG	227	cmp byte [edi], TCP_OPT_MAXSEG
228	je .opt_maxseg	228	je .opt_maxseg
229		229
230	cmp byte [edi], TCP_OPT_WINDOW	230	cmp byte [edi], TCP_OPT_WINDOW
231	je .opt_window	231	je .opt_window
232		232
233	cmp byte [edi], TCP_OPT_TIMESTAMP	233	cmp byte [edi], TCP_OPT_TIMESTAMP
234	je .opt_timestamp	234	je .opt_timestamp
235		235
236	jmp .no_options ; If we reach here, some unknown options were received, skip them all!	236	jmp .no_options ; If we reach here, some unknown options were received, skip them all!
237		237
238	.opt_nop:	238	.opt_nop:
239	inc edi	239	inc edi
240	jmp .opt_loop	240	jmp .opt_loop
241		241
242	.opt_maxseg:	242	.opt_maxseg:
243	cmp byte [edi+1], 4	243	cmp byte [edi+1], 4
244	jne .no_options ; error occured, ignore all options!	244	jne .no_options ; error occured, ignore all options!
245		245
246	test [edx + TCP_segment.Flags], TH_SYN	246	test [edx + TCP_segment.Flags], TH_SYN
247	jz @f	247	jz @f
248		248
249	movzx eax, word[edi+2]	249	movzx eax, word[edi+2]
250	rol ax, 8	250	rol ax, 8
251	DEBUGF 1,"Maxseg: %u\n", ax	251	DEBUGF 1,"Maxseg: %u\n", ax
252		252
253	mov [ebx + TCP_SOCKET.t_maxseg], eax	253	mov [ebx + TCP_SOCKET.t_maxseg], eax
254		254
255	@@:	255	@@:
256	add edi, 4	256	add edi, 4
257	jmp .opt_loop	257	jmp .opt_loop
258		258
259		259
260	.opt_window:	260	.opt_window:
261	cmp byte [edi+1], 3	261	cmp byte [edi+1], 3
262	jne .no_options	262	jne .no_options
263		263
264	test [edx + TCP_segment.Flags], TH_SYN	264	test [edx + TCP_segment.Flags], TH_SYN
265	jz @f	265	jz @f
266		266
267	DEBUGF 1,"Got window option\n"	267	DEBUGF 1,"Got window option\n"
268		268
269	;;;;;	269	;;;;;
270	@@:	270	@@:
271	add edi, 3	271	add edi, 3
272	jmp .opt_loop	272	jmp .opt_loop
273		273
274		274
275	.opt_timestamp:	275	.opt_timestamp:
276	cmp byte [edi+1], 10	276	cmp byte [edi+1], 10
277	jne .no_options	277	jne .no_options
278		278
279	DEBUGF 1,"Got timestamp option\n"	279	DEBUGF 1,"Got timestamp option\n"
280		280
281	;;;;;	281	;;;;;
282		282
283	add edi, 10	283	add edi, 10
284	jmp .opt_loop	284	jmp .opt_loop
285		285
286	.no_options:	286	.no_options:
287		287
288		288
289		289
290		290
291		291
292		292
293	;-----------------------------------------------------------------------	293	;-----------------------------------------------------------------------
294	; Time to do some header prediction (Original Principle by Van Jacobson)	294	; Time to do some header prediction (Original Principle by Van Jacobson)
295		295
296	; There are two common cases for an uni-directional data transfer.	296	; There are two common cases for an uni-directional data transfer.
297	;	297	;
298	; General rule: the packets has no control flags, is in-sequence,	298	; General rule: the packets has no control flags, is in-sequence,
299	; window width didnt change and we're not retransmitting.	299	; window width didnt change and we're not retransmitting.
300	;	300	;
301	; Second rules:	301	; Second rules:
302	; - If the length is 0 and the ACK moved forward, we're the sender side of the transfer.	302	; - If the length is 0 and the ACK moved forward, we're the sender side of the transfer.
303	; In this case we'll free the ACK'ed data and notify higher levels that we have free space in buffer	303	; In this case we'll free the ACK'ed data and notify higher levels that we have free space in buffer
304	;	304	;
305	; - If the length is not 0 and the ACK didn't move, we're the receiver side of the transfer.	305	; - If the length is not 0 and the ACK didn't move, we're the receiver side of the transfer.
306	; If the packets are in order (data queue is empty), add the data to the socket buffer and request a delayed ACK	306	; If the packets are in order (data queue is empty), add the data to the socket buffer and request a delayed ACK
307		307
308	cmp [ebx + TCP_SOCKET.t_state], TCB_ESTABLISHED	308	cmp [ebx + TCP_SOCKET.t_state], TCB_ESTABLISHED
309	jnz .not_uni_xfer	309	jnz .not_uni_xfer
310		310
311	test [edx + TCP_segment.Flags], TH_SYN + TH_FIN + TH_RST + TH_URG	311	test [edx + TCP_segment.Flags], TH_SYN + TH_FIN + TH_RST + TH_URG
312	jnz .not_uni_xfer	312	jnz .not_uni_xfer
313		313
314	test [edx + TCP_segment.Flags], TH_ACK	314	test [edx + TCP_segment.Flags], TH_ACK
315	jz .not_uni_xfer	315	jz .not_uni_xfer
316		316
317	mov eax, [edx + TCP_segment.SequenceNumber]	317	mov eax, [edx + TCP_segment.SequenceNumber]
318	cmp eax, [ebx + TCP_SOCKET.RCV_NXT]	318	cmp eax, [ebx + TCP_SOCKET.RCV_NXT]
319	jne .not_uni_xfer	319	jne .not_uni_xfer
320		320
321	mov eax, dword [edx + TCP_segment.Window]	321	mov eax, dword [edx + TCP_segment.Window]
322	cmp eax, [ebx + TCP_SOCKET.SND_WND]	322	cmp eax, [ebx + TCP_SOCKET.SND_WND]
323	jne .not_uni_xfer	323	jne .not_uni_xfer
324		324
325	mov eax, [ebx + TCP_SOCKET.SND_NXT]	325	mov eax, [ebx + TCP_SOCKET.SND_NXT]
326	cmp eax, [ebx + TCP_SOCKET.SND_MAX]	326	cmp eax, [ebx + TCP_SOCKET.SND_MAX]
327	jne .not_uni_xfer	327	jne .not_uni_xfer
328		328
329	;---------------------------------------	329	;---------------------------------------
330	; check if we are sender in the uni-xfer	330	; check if we are sender in the uni-xfer
331		331
332	; If the following 4 conditions are all true, this segment is a pure ACK.	332	; If the following 4 conditions are all true, this segment is a pure ACK.
333	;	333	;
334	; - The segment contains no data.	334	; - The segment contains no data.
335	test ecx, ecx	335	test ecx, ecx
336	jnz .not_sender	336	jnz .not_sender
337		337
338	; - The congestion window is greater than or equal to the current send window.	338	; - The congestion window is greater than or equal to the current send window.
339	; 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.	339	; 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.
340	mov eax, [ebx + TCP_SOCKET.SND_CWND]	340	mov eax, [ebx + TCP_SOCKET.SND_CWND]
341	cmp eax, [ebx + TCP_SOCKET.SND_WND]	341	cmp eax, [ebx + TCP_SOCKET.SND_WND]
342	jl .not_uni_xfer	342	jl .not_uni_xfer
343		343
344	; - The acknowledgment field in the segment is less than or equal to the maximum sequence number sent.	344	; - The acknowledgment field in the segment is less than or equal to the maximum sequence number sent.
345	mov eax, [edx + TCP_segment.AckNumber]	345	mov eax, [edx + TCP_segment.AckNumber]
346	cmp eax, [ebx + TCP_SOCKET.SND_MAX]	346	cmp eax, [ebx + TCP_SOCKET.SND_MAX]
347	jg .not_uni_xfer	347	jg .not_uni_xfer
348		348
349	; - The acknowledgment field in the segment is greater than the largest unacknowledged sequence number.	349	; - The acknowledgment field in the segment is greater than the largest unacknowledged sequence number.
350	sub eax, [ebx + TCP_SOCKET.SND_UNA]	350	sub eax, [ebx + TCP_SOCKET.SND_UNA]
351	jle .not_uni_xfer	351	jle .not_uni_xfer
352		352
353	DEBUGF 1,"Header prediction: we are sender\n"	353	DEBUGF 1,"Header prediction: we are sender\n"
354		354
355	;---------------------------------	355	;---------------------------------
356	; Packet is a pure ACK, process it	356	; Packet is a pure ACK, process it
357		357
358	; Update RTT estimators	358	; Update RTT estimators
359		359
360	;;; TODO	360	;;; TODO
361		361
362	; Delete acknowledged bytes from send buffer	362	; Delete acknowledged bytes from send buffer
363	pusha	363	pusha
364	mov ecx, eax	364	mov ecx, eax
365	lea eax, [ebx + STREAM_SOCKET.snd]	365	lea eax, [ebx + STREAM_SOCKET.snd]
366	call SOCKET_ring_free	366	call SOCKET_ring_free
367	popa	367	popa
368		368
369	; update window pointers	369	; update window pointers
370	mov eax, [edx + TCP_segment.AckNumber]	370	mov eax, [edx + TCP_segment.AckNumber]
371	mov [ebx + TCP_SOCKET.SND_UNA], eax	371	mov [ebx + TCP_SOCKET.SND_UNA], eax
372		372
373	; Stop retransmit timer	373	; Stop retransmit timer
374	mov [ebx + TCP_SOCKET.timer_ack], 0	374	mov [ebx + TCP_SOCKET.timer_ack], 0
375		375
376	; Awaken waiting processes	376	; Awaken waiting processes
377	mov [ebx + SOCKET.lock], 0	377	mov [ebx + SOCKET.lock], 0
378	mov eax, ebx	378	mov eax, ebx
379	call SOCKET_notify_owner	379	call SOCKET_notify_owner
380		380
381	; Generate more output	381	; Generate more output
382	call TCP_output	382	call TCP_output
383		383
384	jmp .drop_not_locked	384	jmp .drop_not_locked
385		385
386	;-------------------------------------------------	386	;-------------------------------------------------
387	; maybe we are the receiver in the uni-xfer then..	387	; maybe we are the receiver in the uni-xfer then..
388		388
389	.not_sender:	389	.not_sender:
390	; - The amount of data in the segment is greater than 0 (data count is in ecx)	390	; - The amount of data in the segment is greater than 0 (data count is in ecx)
391		391
392	; - The acknowledgment field equals the largest unacknowledged sequence number. This means no data is acknowledged by this segment.	392	; - The acknowledgment field equals the largest unacknowledged sequence number. This means no data is acknowledged by this segment.
393	mov eax, [edx + TCP_segment.AckNumber]	393	mov eax, [edx + TCP_segment.AckNumber]
394	cmp eax, [ebx + TCP_SOCKET.SND_UNA]	394	cmp eax, [ebx + TCP_SOCKET.SND_UNA]
395	jne .not_uni_xfer	395	jne .not_uni_xfer
396		396
397	; - The reassembly list of out-of-order segments for the connection is empty (seg_next equals tp).	397	; - The reassembly list of out-of-order segments for the connection is empty (seg_next equals tp).
398		398
399	;;; TODO	399	;;; TODO
400		400
401	jnz .not_uni_xfer	401	jnz .not_uni_xfer
402		402
403	; Complete processing of received data	403	; Complete processing of received data
404		404
405	DEBUGF 1,"header prediction: we are receiver\nreceiving %u bytes of data\n", ecx	405	DEBUGF 1,"header prediction: we are receiver\nreceiving %u bytes of data\n", ecx
406		406
407	add [ebx + TCP_SOCKET.RCV_NXT], ecx ; Update sequence number with number of bytes we have copied	407	add [ebx + TCP_SOCKET.RCV_NXT], ecx ; Update sequence number with number of bytes we have copied
408		408
409	add esi, edx	409	add esi, edx
410	lea eax, [ebx + STREAM_SOCKET.rcv]	410	lea eax, [ebx + STREAM_SOCKET.rcv]
411	call SOCKET_ring_write ; Add the data to the socket buffer	411	call SOCKET_ring_write ; Add the data to the socket buffer
412		412
413	mov eax, ebx	413	mov eax, ebx
414	call SOCKET_notify_owner	414	call SOCKET_notify_owner
415		415
416	or [ebx + TCP_SOCKET.t_flags], TF_DELACK ; Set delayed ack flag	416	or [ebx + TCP_SOCKET.t_flags], TF_DELACK ; Set delayed ack flag
417		417
418	jmp .drop	418	jmp .drop
419		419
420		420
421		421
422		422
423		423
424		424
425	;--------------------------------------------------	425	;--------------------------------------------------
426	; Header prediction failed, do it the slow way	426	; Header prediction failed, do it the slow way
427		427
428	.not_uni_xfer:	428	.not_uni_xfer:
429		429
430	DEBUGF 1,"Header prediction failed\n"	430	DEBUGF 1,"Header prediction failed\n"
431		431
432	; Calculate receive window size	432	; Calculate receive window size
433		433
434	;;;; TODO: 444	434	;;;; TODO: 444
435		435
436	cmp [ebx + TCP_SOCKET.t_state], TCB_LISTEN	436	cmp [ebx + TCP_SOCKET.t_state], TCB_LISTEN
437	je .LISTEN	437	je .LISTEN
438		438
439	cmp [ebx + TCP_SOCKET.t_state], TCB_SYN_SENT	439	cmp [ebx + TCP_SOCKET.t_state], TCB_SYN_SENT
440	je .SYN_SENT	440	je .SYN_SENT
441		441
442	jmp .NOT_LISTEN_OR_SYN_SENT	442	jmp .NOT_LISTEN_OR_SYN_SENT
443		443
444		444
445		445
446	;-------------	446	;-------------
447	; Passive Open	447	; Passive Open
448		448
449	align 4	449	align 4
450	.LISTEN:	450	.LISTEN:
451		451
452	DEBUGF 1,"TCP state: listen\n"	452	DEBUGF 1,"TCP state: listen\n"
453		453
454	test [edx + TCP_segment.Flags], TH_RST ;;; TODO: kill new socket on error	454	test [edx + TCP_segment.Flags], TH_RST ;;; TODO: kill new socket on error
455	jnz .drop	455	jnz .drop
456		456
457	test [edx + TCP_segment.Flags], TH_ACK	457	test [edx + TCP_segment.Flags], TH_ACK
458	jnz .drop_with_reset	458	jnz .drop_with_reset
459		459
460	test [edx + TCP_segment.Flags], TH_SYN	460	test [edx + TCP_segment.Flags], TH_SYN
461	jz .drop	461	jz .drop
462		462
463	;;; TODO: check if it's a broadcast or multicast, and drop if so	463	;;; TODO: check if it's a broadcast or multicast, and drop if so
464		464
465	add [TCP_sequence_num], 64000	465	add [TCP_sequence_num], 64000
466		466
467	push [edx + TCP_segment.SourcePort]	467	push [edx + TCP_segment.SourcePort]
468	pop [eax + TCP_SOCKET.RemotePort]	468	pop [eax + TCP_SOCKET.RemotePort]
469		469
470	push [edx + TCP_segment.SequenceNumber]	470	push [edx + TCP_segment.SequenceNumber]
471	pop [eax + TCP_SOCKET.IRS]	471	pop [eax + TCP_SOCKET.IRS]
472		472
473	push [eax + TCP_SOCKET.ISS]	473	push [eax + TCP_SOCKET.ISS]
474	pop [eax + TCP_SOCKET.SND_NXT]	474	pop [eax + TCP_SOCKET.SND_NXT]
475		475
476	TCP_sendseqinit eax	476	TCP_sendseqinit eax
477	TCP_rcvseqinit eax	477	TCP_rcvseqinit eax
478		478
479	mov [eax + TCP_SOCKET.t_state], TCB_SYN_RECEIVED	479	mov [eax + TCP_SOCKET.t_state], TCB_SYN_RECEIVED
480	mov [eax + TCP_SOCKET.t_flags], TF_ACKNOW	480	mov [eax + TCP_SOCKET.t_flags], TF_ACKNOW
481	mov [eax + TCP_SOCKET.timer_keepalive], TCP_time_keep_interval ;;;; macro	481	mov [eax + TCP_SOCKET.timer_keepalive], TCP_time_keep_interval ;;;; macro
482		482
483	add eax, STREAM_SOCKET.snd	483	add eax, STREAM_SOCKET.snd
484	call SOCKET_ring_create	484	call SOCKET_ring_create
485		485
486	add eax, STREAM_SOCKET.rcv - STREAM_SOCKET.snd	486	add eax, STREAM_SOCKET.rcv - STREAM_SOCKET.snd
487	call SOCKET_ring_create	487	call SOCKET_ring_create
488		488
489	lea ebx, [eax - STREAM_SOCKET.rcv]	489	lea ebx, [eax - STREAM_SOCKET.rcv]
490	mov [ebx + SOCKET.lock], 0	490	mov [ebx + SOCKET.lock], 0
491		491
492	jmp .trim_then_step6	492	jmp .trim_then_step6
493		493
494		494
495		495
496		496
497		497
498		498
499		499
500		500

Subversion Repositories Kolibri OS

(root)/kernel/branches/net/network/tcp_input.inc – Rev 1773 → 1774