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

-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;                                                              ;;
+;;                                                                 ;;
-;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
+;; Copyright (C) KolibriOS team 2004-2009. All rights reserved.    ;;
-;; Distributed under terms of the GNU General Public License    ;;
+;; Distributed under terms of the GNU General Public License       ;;
-;;                                                              ;;
+;;                                                                 ;;
-;;  TCP.INC                                                     ;;
+;;  TCP.INC                                                        ;;
-;;                                                              ;;
+;;                                                                 ;;
-;;  TCP Processes for Menuet OS  TCP/IP stack                   ;;
+;;  Part of the tcp/ip network stack for KolibriOS                 ;;
-;;                                                              ;;
+;;                                                                 ;;
-;;  Copyright 2002 Mike Hibbett, mikeh@oceanfree.net            ;;
+;;    Written by hidnplayr@kolibrios.org                           ;;
-;;                                                              ;;
+;;                                                                 ;;
-;;  See file COPYING for details                                ;;
+;;          GNU GENERAL PUBLIC LICENSE                             ;;
-;;  v0.6 : Added reset handling in the established state        ;;
-;;         Added a timer per socket to allow delays when        ;;
-;;         rx window gets below 1KB                             ;;
+;;             Version 2, June 1991                                ;;
-;;                                                              ;;
+;;                                                                 ;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 $Revision: 1019 $
-TWOMSL			equ 10	    ; # of secs to wait before closing socket
+TWOMSL			equ 10		; # of secs to wait before closing socket
-TCP_RETRIES		equ 5		    ; Number of times to resend a Packet
+TCP_RETRIES		equ 5		; Number of times to resend a Packet
+TCP_TIMEOUT		equ 10		; resend if not replied to in x hs
-TCP_TIMEOUT		equ 10		    ; resend if not replied to in x hs
+TCP_QUEUE_SIZE		equ 16
 struct	TCP_Packet
 	.SourcePort		dw ?
 	.DestinationPort	dw ?
 	.Options		rb 3
 	.Padding		db ?
 	.Data:
 ends
+align 4
+uglobal
+	TCP_PACKETS_TX		rd  MAX_IP
+	TCP_PACKETS_RX		rd  MAX_IP
+	TCP_IN_QUEUE	rd  3*TCP_QUEUE_SIZE+3
+	TCP_OUT_QUEUE	rd  3*TCP_QUEUE_SIZE+3
+endg
+;-----------------------------------------------------------------
+;
+; TCP_init
+;
+;  This function resets all TCP variables
+;
+;  IN:  /
+;  OUT: /
+;
+;-----------------------------------------------------------------
+align 4
+TCP_init:
+	xor	eax, eax
+	mov	edi, TCP_PACKETS_TX
+	mov	ecx, 2*MAX_IP
+	rep	stosd
+	mov	dword [TCP_IN_QUEUE], TCP_QUEUE_SIZE
+	mov	dword [TCP_IN_QUEUE+4], TCP_IN_QUEUE + queue.data
+	mov	dword [TCP_IN_QUEUE+8], TCP_IN_QUEUE + queue.data
+	mov	dword [TCP_OUT_QUEUE], TCP_QUEUE_SIZE
+	mov	dword [TCP_OUT_QUEUE+4], TCP_OUT_QUEUE + queue.data
+	mov	dword [TCP_OUT_QUEUE+8], TCP_OUT_QUEUE + queue.data
+	ret
-;***************************************************************************
+;-----------------------------------------------------------------
 ;   Function
-;      tcp_tcb_handler
 ;      tcp_tcb_handler
 ;   Description
 ;       Handles sockets in the timewait state, closing them
 ;       when the TCB timer expires
+;
 ;-----------------------------------------------------------------
 ;***************************************************************************
 align 4
   .next_socket:
 	mov	ebx, [ebx + SOCKET.NextPtr]
 	or	ebx, ebx
 	jz	.exit
-	DEBUGF	1, "K :   %x-%x: %x-%x-%x-%u\n", [ebx + SOCKET.PID]:2, [ebx + SOCKET.Number]:2, [ebx + SOCKET.LocalPort]:4, [ebx + SOCKET.RemoteIP], [ebx + SOCKET.RemotePort]:4, [ebx + SOCKET.TCBState]
+;        DEBUGF  1, "K :   %x-%x: %x-%x-%x-%u\n", [ebx + SOCKET.PID]:2, [ebx + SOCKET.Number]:2, [ebx + SOCKET.LocalPort]:4, [ebx + SOCKET.RemoteIP], [ebx + SOCKET.RemotePort]:4, [ebx + SOCKET.TCBState]
 	cmp	[ebx + SOCKET.TCBTimer], 0
 	jne	.decrement_tcb
 ;       Handles queued TCP data
 ;       This is a kernel function, called by stack_handler
+;
 ;***************************************************************************
+align 4
-proc tcp_tx_handler stdcall
+tcp_tx_handler:
     ; decrement all resend buffers timers. If they
     ; expire, queue them for sending, and restart the timer.
     ; If the retries counter reach 0, delete the entry
 	mov	esi, resendQ
 	mov	ecx, 0
   .next_resendq:
-	cmp	ecx, NUMRESENDENTRIES
+;        cmp     ecx, NUMRESENDENTRIES
 	je	.exit		    ; None left
 	cmp	dword[esi + 4], 0
 	xchg	 [esi + 4], ebx
     @@: ; resend Packet
 	pushad
-	mov	eax, EMPTY_QUEUE
+;        mov     eax, EMPTY_QUEUE
-	call	dequeue
+;        call    dequeue
-	cmp	ax, NO_BUFFER
+;        cmp     ax, NO_BUFFER
 	jne	.tth004z
 	mov	word[esi + 2], 1
 	jmp	.tth005
   .tth004z:
 	; we have a buffer # in ax
-	push	eax ecx
+;        push    eax ecx
-	mov	ecx, IPBUFFSIZE
+;        mov     ecx, IPBUFFSIZE
-	mul	ecx
+;        mul     ecx
-	add	eax, IPbuffs
+;        add     eax, IPbuffs
 	; we have the buffer address in eax
 	mov	edi, eax
 	pop	ecx
 	; Now get buffer location, and copy buffer across. argh! more copying,,
-	mov	esi, resendBuffer
+;        mov     esi, resendBuffer
-    @@: add	esi, IPBUFFSIZE
+;    @@: add     esi, IPBUFFSIZE
 	loop	@b
 	; we have resend buffer location in esi
-	mov	ecx, IPBUFFSIZE
+;        mov     ecx, IPBUFFSIZE
 	; copy data across
 	push	edi
 	cld
 	rep	movsb
 	pop	edi
 	; queue Packet
-	mov	eax, NET1OUT_QUEUE
+;        mov     eax, NET1OUT_QUEUE
-	mov	edx, [IP_LIST]
+;        mov     edx, [IP_LIST]
-	cmp	edx, [edi + IP_Packet.DestinationAddress]
+;        cmp     edx, [edi + IP_Packet.DestinationAddress]
-	jne	.not_local
+;        jne     .not_local
-	mov	eax, IPIN_QUEUE
+;        mov     eax, IPIN_QUEUE
   .not_local:
 	pop	ebx
-	call	queue
+;        call    queue
-  .tth005:
+  .tth005:
 	popad
-	inc	ecx
 	add	esi, 8
-	jmp	.next_resendq
+	inc	ecx
-  .exit:
-	ret
-endp
 	add	esi, 8
+	jmp	.next_resendq
-;***************************************************************************
+  .exit:
+	ret
+;-----------------------------------------------------------------
+;
+; TCP_Handler:
+;
+;  Called by IPv4_handler,
-;   Function
-;      tcp_rx
-;
-;   Description
-;       TCP protocol handler
-;       This is a kernel function, called by ip_rx
+;  this procedure will inject the tcp data diagrams in the application sockets.
-;       IP buffer address given in edx
-;          IP buffer number in eax
-;          Free up (or re-use) IP buffer when finished
-;
-;***************************************************************************
+;
+;  IN:  Pointer to buffer in [esp]
+;       size of buffer in [esp+4]
+;       pointer to device struct in ebx
-proc tcp_rx stdcall uses ebx
+;       TCP Packet size in ecx
-	; The process is as follows.
+;       pointer to TCP Packet data in edx
-	; Look for a socket with matching remote IP, remote port, local port
+;       SourceAddres in esi
-	; if not found, then
+;  OUT: /
 	or	ebx, ebx
 	jz	.next_socket.1.exit
 ;        DEBUGF  1, "K : tcp_rx - 1.dport: %x - %x\n", [edx + 20 + TCP_Packet.DestinationPort]:4, [ebx + SOCKET.LocalPort]:4
-	mov	ax, [edx + 20 + TCP_Packet.DestinationPort]  ; get the dest. port from the TCP hdr
+	mov	ax, [edx + TCP_Packet.DestinationPort]	; get the dest. port from the TCP hdr
 	cmp	[ebx + SOCKET.LocalPort], ax		; get the dest. port from the TCP hdr
 	jne	.next_socket.1				; different - try next socket
 ;        DEBUGF  1, "K : tcp_rx - 1.addr: %x - %x\n", [edx + IP_Packet.SourceAddress], [ebx + SOCKET.RemoteIP]
-	mov	eax, [edx + IP_Packet.SourceAddress]	; get the source IP Addr from the IP hdr
+	mov	eax, esi ;[edx + IP_Packet.SourceAddress]    ; get the source IP Addr from the IP hdr
 	cmp	[ebx + SOCKET.RemoteIP], eax		; compare with socket's remote IP
 	jne	.next_socket.1				; different - try next socket
 ;        DEBUGF  1, "K : tcp_rx - 1.sport: %x - %x\n", [edx + 20 + TCP_Packet.SourcePort]:4, [ebx + SOCKET.RemotePort]:4
 	or	ebx, ebx
 	jz	.next_socket.2.exit
 ;        DEBUGF  1, "K : tcp_rx - 2.dport: %x - %x\n", [edx + 20 + TCP_Packet.DestinationPort]:4, [ebx + SOCKET.LocalPort]:4
-	mov	ax, [edx + 20 + TCP_Packet.DestinationPort]  ; get the dest. port from the TCP hdr
+	mov	ax, [edx + TCP_Packet.DestinationPort]	; get the dest. port from the TCP hdr
 	cmp	[ebx + SOCKET.LocalPort], ax		; compare with socket's local port
 	jne	.next_socket.2				; different - try next socket
 ;        DEBUGF  1, "K : tcp_rx - 2.addr: %x - %x\n", [edx + IP_Packet.SourceAddress], [ebx + SOCKET.RemoteIP]
-	mov	eax, [edx + IP_Packet.SourceAddress]	; get the source IP Addr from the IP hdr
+;        mov     eax, esi ;[edx + IP_Packet.SourceAddress]    ; get the source IP Addr from the IP hdr
 	or	ebx, ebx
 	jz	.next_socket.3.exit
 ;        DEBUGF  1, "K : tcp_rx - 3.dport: %x - %x\n", [edx + 20 + TCP_Packet.DestinationPort]:4, [ebx + SOCKET.LocalPort]:4
-	mov	ax, [edx + 20 + TCP_Packet.DestinationPort]  ; get destination port from the TCP hdr
+	mov	ax, [edx + TCP_Packet.DestinationPort]	; get destination port from the TCP hdr
 	cmp	[ebx + SOCKET.LocalPort], ax		; compare with socket's local port
   .next_socket.3.exit:
 	; If we got here, we need to reject the Packet
 	DEBUGF	1, "K : tcp_rx - dumped\n"
-	DEBUGF	1, "K :   --------: %x-%x-%x (flags: %x)\n", [edx + 20 + TCP_Packet.DestinationPort]:4, [edx + IP_Packet.SourceAddress], [edx + 20 + TCP_Packet.SourcePort]:4, [edx + 20 + TCP_Packet.Flags]:2
+;        DEBUGF  1, "K :   --------: %x-%x-%x (flags: %x)\n", [edx + 20 + TCP_Packet.DestinationPort]:4, [edx + IP_Packet.SourceAddress], [edx + 20 + TCP_Packet.SourcePort]:4, [edx + 20 + TCP_Packet.Flags]:2
-	inc	[dumped_rx_count]
+;        inc     [dumped_rx_count]
 	; IP buffer number is on stack ( it will be popped at the end)
 	stdcall tcpStateMachine, ebx
   .exit:
+	call	kernel_free
-	pop	eax
+	add	esp, 4 ; pop (balance stack)
-	call	freeBuff
+ret
+;-----------------------------------------------------------------
+;
+; IN: eax = dest ip
+;     ebx = source ip
+;     ecx = data length
+;     edx = remote port shl 16 + local port
+;     esi = data offset
+;
+;-----------------------------------------------------------------
 	ret
-endp
+TCP_create_Packet:
 	DEBUGF 1,"Create TCP Packet\n"
 ;***************************************************************************
 ;       Data length in ecx
 ;          Transmit buffer number in eax
+;
 ;***************************************************************************
 proc build_tcp_Packet stdcall, sockAddr:DWORD
-	push	ecx			   ; Save data length
+	push	ecx			   ; Save data length
-	; convert buffer pointer eax to the absolute address
-	mov	ecx, IPBUFFSIZE
+	add	ecx, UDP_Packet.Data
+	mov	di , IP_PROTO_UDP
-	mul	ecx
+;       dx  = fragment id
-	add	eax, IPbuffs
+	call	IPv4_create_Packet				; TODO: figure out a way to choose between IPv4 and IPv6
+	cmp	edi, -1
-	mov	edx, eax
+	je	.exit
-	mov	[edx + 20 + TCP_Packet.Flags], bl		; TCP flags
+	mov	[edi + TCP_Packet.Flags], bl		   ; TCP flags
-	mov	ebx, [sockAddr]
+;        mov     ebx, [sockAddr];---------------------------------------------------------- eof
 	; So, ebx holds the socket ptr, edx holds the IPbuffer ptr
 	; Fill in the IP header ( some data is in the socket descriptor)
 	mov	eax, [ebx + SOCKET.LocalIP]
-	mov	[edx + IP_Packet.SourceAddress], eax
+;        mov     [edx + IP_Packet.SourceAddress], eax
 	mov	eax, [ebx + SOCKET.RemoteIP]
-	mov	[edx + IP_Packet.DestinationAddress], eax
+;        mov     [edx + IP_Packet.DestinationAddress], eax
-	mov	[edx + IP_Packet.VersionAndIHL], 0x45
+;        mov     [edx + IP_Packet.VersionAndIHL], 0x45
-	mov	[edx + IP_Packet.TypeOfService], 0
+;        mov     [edx + IP_Packet.TypeOfService], 0
 	pop	eax		      ; Get the TCP data length
 	push	eax
 	add	eax, 20 + 20	       ; add IP header and TCP header lengths
 	rol	ax, 8
 	rep	movsb		    ; copy the data across
     @@: ; we have edx as IPbuffer ptr.
 	; Fill in the TCP checksum
 	; First, fill in pseudoheader
-	mov	eax, [edx + IP_Packet.SourceAddress]
+;        mov     eax, [edx + IP_Packet.SourceAddress]
-	mov	[pseudoHeader], eax
+;        mov     [pseudoHeader], eax
-	mov	eax, [edx + IP_Packet.DestinationAddress]
+;        mov     eax, [edx + IP_Packet.DestinationAddress]
-	mov	[pseudoHeader + 4], eax
+;        mov     [pseudoHeader + 4], eax
-	mov	word[pseudoHeader + 8], PROTOCOL_TCP shl 8 + 0
+;        mov     word[pseudoHeader + 8], PROTOCOL_TCP shl 8 + 0
-	add	ebx, 20
+;        add     ebx, 20
-	mov	[pseudoHeader + 10], bh
+;        mov     [pseudoHeader + 10], bh
-	mov	[pseudoHeader + 11], bl
+;        mov     [pseudoHeader + 11], bl
+;
-	mov	eax, pseudoHeader
+;        mov     eax, pseudoHeader
-	mov	[checkAdd1], eax
+;        mov     [checkAdd1], eax
-	mov	word[checkSize1], 12
+;        mov     word[checkSize1], 12
-	mov	eax, edx
+;        mov     eax, edx
-	add	eax, 20
+;        add     eax, 20
-	mov	[checkAdd2], eax
+;        mov     [checkAdd2], eax
-	mov	eax, ebx
+;        mov     eax, ebx
-	mov	[checkSize2], ax
+;        mov     [checkSize2], ax
+;
-	call	checksum
+;        call    checksum
 	; store it in the TCP checksum ( in the correct order! )
-	mov	ax, [checkResult]
+;        mov     ax, [checkResult]
-	rol	ax, 8
+;        rol     ax, 8
-	mov	[edx + 20 + TCP_Packet.Checksum], ax
+;        mov     [edx + 20 + TCP_Packet.Checksum], ax
 	; Fill in the IP header checksum
-    movzx   eax, byte [edx + IP_Packet.VersionAndIHL]  ; Calculate Header length by using IHL field
+;    movzx   eax, byte [edx + IP_Packet.VersionAndIHL]  ; Calculate Header length by using IHL field
-    and     eax, 0x0000000F  ;
+;    and     eax, 0x0000000F  ;
-    shl     eax, 2	     ;
+;    shl     eax, 2           ;
+;
+	stdcall checksum_jb, edx, eax  ; buf_ptr, buf_size
+	rol	ax, 8
+;        mov     [edx + IP_Packet.HeaderChecksum], ax
+       .exit:
 	stdcall checksum_jb, edx, eax  ; buf_ptr, buf_size
-	rol	ax, 8
+	call	kernel_free
-	mov	[edx + IP_Packet.HeaderChecksum], ax
+	add	esp, 4 ; pop (balance stack)
 	ret
-endp
+;endp
 ; Increments the 32 bit value pointed to by esi in internet order
 proc inc_inet_esi stdcall
-	push	eax
+;        push    eax
-	mov	eax, [esi]
+;        mov     eax, [esi]
+;        bswap   eax
+;        inc     eax
+;        bswap   eax
+;        mov     [esi], eax
-	bswap	eax
+;        pop     eax
-	inc	eax
+;        ret
-	bswap	eax
+	inc	byte[esi+0]
 	mov	esi, resendQ
 	xor	ecx, ecx
   .next_resendq:
-	cmp	ecx, NUMRESENDENTRIES
+;        cmp     ecx, NUMRESENDENTRIES
 	je	.call_handler	  ; None left
 	cmp	[esi + 4], eax
 	je	@f		  ; found one
 			  ; If yes, goto @@. No, goto .next_resendq
 	; Get Packet data address
 	push	ecx
 	; Now get buffer location, and copy buffer across. argh! more copying,,
-	imul	edi, ecx, IPBUFFSIZE
+;        imul    edi, ecx, IPBUFFSIZE
-	add	edi, resendBuffer
+;        add     edi, resendBuffer
 	; we have dest buffer location in edi. incoming Packet in edx.
 	; Get this Packets sequence number
 	jz	.exit
 	; We have a SYN. update the socket with this IP Packets details,
 	; And send a response
-	mov	eax, [edx + IP_Packet.SourceAddress]
+;        mov     eax, [edx + IP_Packet.SourceAddress]
-	mov	[ebx + SOCKET.RemoteIP], eax
+ ;       mov     [ebx + SOCKET.RemoteIP], eax
-	mov	ax, [edx + 20 + TCP_Packet.SourcePort]
+;        mov     ax, [edx + 20 + TCP_Packet.SourcePort]
-	mov	[ebx + SOCKET.RemotePort], ax
+;        mov     [ebx + SOCKET.RemotePort], ax
-	mov	eax, [edx + 20 + TCP_Packet.SequenceNumber]
+;        mov     eax, [edx + 20 + TCP_Packet.SequenceNumber]
-	mov	[ebx + SOCKET.IRS], eax
+;        mov     [ebx + SOCKET.IRS], eax
-	mov	[ebx + SOCKET.RCV_NXT], eax
+;        mov     [ebx + SOCKET.RCV_NXT], eax
-	lea	esi, [ebx + SOCKET.RCV_NXT]
+;        lea     esi, [ebx + SOCKET.RCV_NXT]
-	call	inc_inet_esi ; RCV.NXT
+;        call    inc_inet_esi ; RCV.NXT
-	mov	eax, [ebx + SOCKET.ISS]
+;        mov     eax, [ebx + SOCKET.ISS]
-	mov	[ebx + SOCKET.SND_NXT], eax
+;        mov     [ebx + SOCKET.SND_NXT], eax
+;
 	; Now construct the response, and queue for sending by IP
-	mov	eax, EMPTY_QUEUE
+;        mov     eax, EMPTY_QUEUE
-	call	dequeue
+;        call    dequeue
-	cmp	ax, NO_BUFFER
+;        cmp     ax, NO_BUFFER
-	je	.exit
+ ;       je      .exit
 	push	eax
 	mov	bl, TH_SYN + TH_ACK
 	xor	ecx, ecx
 	xor	esi, esi
-	stdcall build_tcp_Packet, [sockAddr]
+;        stdcall build_tcp_Packet, [sockAddr]
-	mov	eax, NET1OUT_QUEUE
+;        mov     eax, NET1OUT_QUEUE
 ;;;        mov     edx, [stack_ip]
 	mov	ecx, [sockAddr]
 	cmp	edx, [ecx + SOCKET.RemoteIP]
 	jne	.not_local
-	mov	eax, IPIN_QUEUE
+;        mov     eax, IPIN_QUEUE
   .not_local:
 	; Send it.
 	lea	esi, [ebx + SOCKET.RCV_NXT]
 	call	inc_inet_esi
 	; Send an ACK
 	; Now construct the response, and queue for sending by IP
-	mov	eax, EMPTY_QUEUE
+;        mov     eax, EMPTY_QUEUE
-	call	dequeue
+;        call    dequeue
-	cmp	ax, NO_BUFFER
+ ;       cmp     ax, NO_BUFFER
 	pop	ebx
 	je	.exit
 	push	eax
 	xor	ecx, ecx
 	xor	esi, esi
-	stdcall build_tcp_Packet, [sockAddr]
+;        stdcall build_tcp_Packet, [sockAddr]
-	mov	eax, NET1OUT_QUEUE
+;        mov     eax, NET1OUT_QUEUE
 ;;;        mov     edx, [stack_ip]
-	mov	ecx, [sockAddr]
+;        mov     ecx, [sockAddr]
-	cmp	edx, [ecx + SOCKET.RemoteIP]
+ ;       cmp     edx, [ecx + SOCKET.RemoteIP]
-	jne	.not_local
+  ;      jne     .not_local
-	mov	eax, IPIN_QUEUE
+   ;     mov     eax, IPIN_QUEUE
   .not_local:
 	; Send it.
 	mov	esi, resendQ
 	mov	ecx, 0
   .next_resendq:
-	cmp	ecx, NUMRESENDENTRIES
+;        cmp     ecx, NUMRESENDENTRIES
-	je	.last_resendq	    ; None left
+;        je      .last_resendq       ; None left
-	cmp	[esi + 4], eax
+;        cmp     [esi + 4], eax
-	je	@f		    ; found one
+;        je      @f                  ; found one
-	inc	ecx
+;        inc     ecx
-	add	esi, 8
+;        add     esi, 8
-	jmp	.next_resendq
+;        jmp     .next_resendq
     @@: mov	dword[esi + 4], 0
     @@: cmp	ecx, [edx + 20 + TCP_Packet.SequenceNumber]
 	jne	.ack
 	; Read the data bytes, store in socket buffer
-	movzx	ecx, [edx + IP_Packet.TotalLength]
+;        movzx   ecx, [edx + IP_Packet.TotalLength]
 	xchg	cl, ch
 	sub	ecx, 40 		   ; Discard 40 bytes of header
 	call	add_inet_esi
   .ack:
 	; Send an ACK
 	; Now construct the response, and queue for sending by IP
-	mov	eax, EMPTY_QUEUE
+;        mov     eax, EMPTY_QUEUE
-	call	dequeue
+;        call    dequeue
-	cmp	ax, NO_BUFFER
+;        cmp     ax, NO_BUFFER
 	je	.exit
 	push	eax
 	mov	bl, TH_ACK
 	xor	ecx, ecx
 	xor	esi, esi
-	stdcall build_tcp_Packet, [sockAddr]
+;        stdcall build_tcp_Packet, [sockAddr]
-	mov	eax, NET1OUT_QUEUE
+;        mov     eax, NET1OUT_QUEUE
 ;;;        mov     edx, [stack_ip]
-	mov	ecx, [sockAddr]
+;        mov     ecx, [sockAddr]
-	cmp	edx, [ecx + SOCKET.RemoteIP]
+;        cmp     edx, [ecx + SOCKET.RemoteIP]
-	jne	.not_local
+;        jne     .not_local
-	mov	eax, IPIN_QUEUE
+ ;       mov     eax, IPIN_QUEUE
   .not_local:
 	; Send it.
     @@: lea	esi, [ebx + SOCKET.RCV_NXT]
 	call	inc_inet_esi
 	; Send an ACK
-	mov	eax, EMPTY_QUEUE
+;        mov     eax, EMPTY_QUEUE
-	call	dequeue
+;        call    dequeue
-	cmp	ax, NO_BUFFER
+;        cmp     ax, NO_BUFFER
 	je	.exit
 	push	eax
 	mov	bl, TH_ACK
 	xor	ecx, ecx
 	xor	esi, esi
-	stdcall build_tcp_Packet, [sockAddr]
+;        stdcall build_tcp_Packet, [sockAddr]
-	mov	eax, NET1OUT_QUEUE
+;        mov     eax, NET1OUT_QUEUE
 ;;;        mov     edx, [stack_ip]
-	mov	ecx, [sockAddr]
+;        mov     ecx, [sockAddr]
-	cmp	edx, [ecx + SOCKET.RemoteIP]
+ ;       cmp     edx, [ecx + SOCKET.RemoteIP]
-	jne	.not_local
+ ;       jne     .not_local
-	mov	eax, IPIN_QUEUE
+;        mov     eax, IPIN_QUEUE
   .not_local:
 	lea	esi, [ebx + SOCKET.RCV_NXT]
 	call	inc_inet_esi
 	; Send an ACK
-	mov	eax, EMPTY_QUEUE
+;        mov     eax, EMPTY_QUEUE
-	call	dequeue
+;        call    dequeue
-	cmp	ax, NO_BUFFER
+ ;;       cmp     ax, NO_BUFFER
-	je	.exit
+  ;      je      .exit
 	push	eax
 	mov	bl, TH_ACK
 	xor	ecx, ecx
 	xor	esi, esi
-	stdcall build_tcp_Packet, [sockAddr]
+;        stdcall build_tcp_Packet, [sockAddr]
-	mov	eax, NET1OUT_QUEUE
+;        mov     eax, NET1OUT_QUEUE
 ;;;        mov     edx, [stack_ip]
 	mov	ecx, [sockAddr]
 	cmp	edx, [ecx + SOCKET.RemoteIP]
 	jne	.not_local
-	mov	eax, IPIN_QUEUE
+;        mov     eax, IPIN_QUEUE
   .not_local:
 ; @param EBX is socket number
 ; @param ECX is application data size (number of bytes to send)
 ; @param EDX is pointer to application data buffer
 ; @return 0 (sent successfully) or -1 (error) in EAX
 ;;
-proc socket_write_tcp stdcall
+;proc socket_write_tcp stdcall
-local sockAddr dd ?
+;local sockAddr dd ?
 ;        DEBUGF  1, "socket_write_tcp(0x%x)\n", ebx
 	stdcall net_socket_num_to_addr, ebx
 	or	eax, eax
 	jz	.error
 	mov	ebx, eax
-	mov	[sockAddr], ebx
+;        mov     [sockAddr], ebx
 	; If the sockets window timer is nonzero, do not queue Packet
 	cmp	[ebx + SOCKET.wndsizeTimer], 0
 	jne	.error
-	mov	eax, EMPTY_QUEUE
+;        mov     eax, EMPTY_QUEUE
-	call	dequeue
+;        call    dequeue
-	cmp	ax, NO_BUFFER
+;        cmp     ax, NO_BUFFER
 	pop	eax
 	push	eax
 	push	ecx
 	mov	bl, TH_ACK
-	stdcall build_tcp_Packet, [sockAddr]
+;        stdcall build_tcp_Packet, [sockAddr]
 	pop	ecx
 	; Check destination IP address.
 	; If it is the local host IP, route it back to IP_RX
 	pop	ebx
 	push	ecx
-	mov	eax, NET1OUT_QUEUE
+;        mov     eax, NET1OUT_QUEUE
 ;;; TODO: get device id in edx
 	xor	edx, edx
 	shl	edx, 2
 	mov	edx, [IP_LIST+edx]
-	mov	ecx, [sockAddr]
+;        mov     ecx, [sockAddr]
-	cmp	edx, [ecx + SOCKET.RemoteIP]
+ ;       cmp     edx, [ecx + SOCKET.RemoteIP]
-	jne	.not_local
+  ;      jne     .not_local
-	mov	eax, IPIN_QUEUE
+   ;     mov     eax, IPIN_QUEUE
   .not_local:
 	pop	ecx
 	push	ebx		    ; save ipbuffer number
 	; If there isn't one, dont worry about it for now
 	mov	esi, resendQ
 	mov	ecx, 0
   .next_resendq:
-	cmp	ecx, NUMRESENDENTRIES
+;        cmp     ecx, NUMRESENDENTRIES
 	je	.exit		   ; None found
 	cmp	dword[esi + 4], 0
 	je	@f		   ; found one
 	inc	ecx
 	;  socket #
 	;  retries count
 	;  retry time
 	;  fill IP buffer associated with this descriptor
-	stdcall net_socket_addr_to_num, [sockAddr]
+;        stdcall net_socket_addr_to_num, [sockAddr]
 	mov	[esi + 4], eax
 	mov	byte[esi + 1], TCP_RETRIES
 	mov	word[esi + 2], TCP_TIMEOUT
 	inc	ecx
 	; Now get buffer location, and copy buffer across. argh! more copying,,
-	mov	edi, resendBuffer - IPBUFFSIZE
+;        mov     edi, resendBuffer - IPBUFFSIZE
-    @@: add	edi, IPBUFFSIZE
+;    @@: add     edi, IPBUFFSIZE
 	loop	@b
 	; we have dest buffer location in edi
 	pop	eax
 	; convert source buffer pointer eax to the absolute address
-	mov	ecx, IPBUFFSIZE
+;        mov     ecx, IPBUFFSIZE
-	mul	ecx
+;        mul     ecx
-	add	eax, IPbuffs
+;        add     eax, IPbuffs
-	mov	esi, eax
+;        mov     esi, eax
 	; do copy
-	mov	ecx, IPBUFFSIZE
+;        mov     ecx, IPBUFFSIZE
 ;        cld
 	rep	movsb
   .exit:
 	xor	eax, eax
 	ret
 ;***************************************************************************
 checksum:
     pusha
-    mov     eax, [checkAdd1]
+;    mov     eax, [checkAdd1]
     xor     edx, edx		      ; edx is the accumulative checksum
     xor     ebx, ebx
-    mov     cx, [checkSize1]
+;    mov     cx, [checkSize1]
     shr     cx, 1
     jz	    cs1_1
     add     edx, ebx
     loopw   cs1
 cs1_1:
-    and     word [checkSize1], 0x01
+;    and     word [checkSize1], 0x01
     jz	    cs_test2
     mov     bh, [eax]
     xor     bl, bl
     add     edx, ebx
 cs_test2:
-    mov     cx, [checkSize2]
+;    mov     cx, [checkSize2]
     cmp     cx, 0
     add     edx, ebx
     loopw   cs2
 cs2_1:
-    and     word [checkSize2], 0x01
+;    and     word [checkSize2], 0x01
     jz	    cs_exit
     mov     eax, edx
     shr     eax, 16
     add     edx, eax
     not     dx
-    mov     [checkResult], dx
+;    mov     [checkResult], dx
     popa
-    ret
-TCP_HANDLER:
-;;; TODO: write code here
-    call    kernel_free
-    add     esp, 4 ; pop (balance stack)
-ret

Subversion Repositories Kolibri OS

(root)/kernel/branches/net/network/tcp.inc – Rev 1161 → 1196