kolibrios/kernel/branches/Kolibri-acpi/network/socket.inc

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;  SOCKET.INC                                                  ;;
;;                                                              ;;
;;  Sockets constants, structures and functions                 ;;
;;                                                              ;;
;;  This file contains the following:                           ;;
;;    is_localport_unused                                       ;;
;;    get_free_socket                                           ;;
;;    socket_open                                               ;;
;;    socket_open_tcp                                           ;;
;;    socket_close                                              ;;
;;    socket_close_tcp                                          ;;
;;    socket_poll                                               ;;
;;    socket_status                                             ;;
;;    socket_read                                               ;;
;;    socket_write                                              ;;
;;    socket_write_tcp                                          ;;
;;                                                              ;;
;;                                                              ;;
;;  Changes history:                                            ;;
;;   22.09.2003 - [Mike Hibbett] : mikeh@oceanfree.net          ;;
;;   11.11.2006 - [Johnny_B] and [smb]                          ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

$Revision$

; socket data structure
struct SOCKET
  .PrevPtr	  dd ? ; pointer to previous socket in list
  .NextPtr	  dd ? ; pointer to next socket in list
  .Number	  dd ? ; socket number (unique within single process)
  .PID		  dd ? ; application process id
  .LocalIP	  dd ? ; local IP address
  .LocalPort	  dw ? ; local port
  .RemoteIP	  dd ? ; remote IP address
  .RemotePort	  dw ? ; remote port
  .OrigRemoteIP   dd ? ; original remote IP address (used to reset to LISTEN state)
  .OrigRemotePort dw ? ; original remote port (used to reset to LISTEN state)
  .rxDataCount	  dd ? ; rx data count
  .TCBState	  dd ? ; TCB state
  .TCBTimer	  dd ? ; TCB timer (seconds)
  .ISS		  dd ? ; initial send sequence
  .IRS		  dd ? ; initial receive sequence
  .SND_UNA	  dd ? ; sequence number of unack'ed sent packets
  .SND_NXT	  dd ? ; bext send sequence number to use
  .SND_WND	  dd ? ; send window
  .RCV_NXT	  dd ? ; next receive sequence number to use
  .RCV_WND	  dd ? ; receive window
  .SEG_LEN	  dd ? ; segment length
  .SEG_WND	  dd ? ; segment window
  .wndsizeTimer   dd ? ; window size timer
  .lock           dd ? ; lock mutex
  .rxData	  dd ? ; receive data buffer here
ends

; TCP opening modes
SOCKET_PASSIVE = 0
SOCKET_ACTIVE  = 1

; socket types
SOCK_STREAM = 1
SOCK_DGRAM  = 2

; pointer to bitmap of free ports (1=free, 0=used)
uglobal
align 4
network_free_ports	dd	?
endg

iglobal
align 4
network_free_hint	dd	1024/8
endg

;; Allocate memory for socket data and put new socket into the list
; Newly created socket is initialized with calling PID and number and
; put into beginning of list (which is a fastest way).
;
; @return socket structure address in EAX
;;
proc net_socket_alloc stdcall uses ebx ecx edx edi
	stdcall kernel_alloc, SOCKETBUFFSIZE
	DEBUGF	1, "K : net_socket_alloc (0x%x)\n", eax
	; check if we can allocate needed amount of memory
	or	eax, eax
	jz	.exit

	; zero-initialize allocated memory
	push	eax
	mov	edi, eax
	mov	ecx, SOCKETBUFFSIZE / 4
	cld
	xor	eax, eax
	rep	stosd
	pop	eax

	; add socket to the list by changing pointers
	mov	ebx, net_sockets
	push	[ebx + SOCKET.NextPtr]
	mov	[ebx + SOCKET.NextPtr], eax
	mov	[eax + SOCKET.PrevPtr], ebx
	pop	ebx
	mov	[eax + SOCKET.NextPtr], ebx
	or	ebx, ebx
	jz	@f
	mov	[ebx + SOCKET.PrevPtr], eax

    @@: ; set socket owner PID to the one of calling process
	mov	ebx, [TASK_BASE]
	mov	ebx, [ebx + TASKDATA.pid]
	mov	[eax + SOCKET.PID], ebx

	; find first free socket number and use it
	;mov     edx, ebx
	mov	ebx, net_sockets
	xor	ecx, ecx
  .next_socket_number:
	inc	ecx
  .next_socket:
	mov	ebx, [ebx + SOCKET.NextPtr]
	or	ebx, ebx
	jz	.last_socket_number
	cmp	[ebx + SOCKET.Number], ecx
	jne	.next_socket
	;cmp     [ebx + SOCKET.PID], edx
	;jne     .next_socket
	mov	ebx, net_sockets
	jmp	.next_socket_number

  .last_socket_number:
	mov	[eax + SOCKET.Number], ecx

  .exit:
	ret
endp

;; Free socket data memory and pop socket off the list
;
; @param sockAddr is a socket structure address
;;
proc net_socket_free stdcall uses ebx ecx edx, sockAddr:DWORD
	mov	eax, [sockAddr]
	DEBUGF	1, "K : net_socket_free (0x%x)\n", eax
	; check if we got something similar to socket structure address
	or	eax, eax
	jz	.error

	; make sure sockAddr is one of the socket addresses in the list
	mov	ebx, net_sockets
	;mov     ecx, [TASK_BASE]
	;mov     ecx, [ecx + TASKDATA.pid]
  .next_socket:
	mov	ebx, [ebx + SOCKET.NextPtr]
	or	ebx, ebx
	jz	.error
	cmp	ebx, eax
	jne	.next_socket
	;cmp     [ebx + SOCKET.PID], ecx
	;jne     .next_socket

	; okay, we found the correct one
	; mark local port as unused
	movzx	ebx, [eax + SOCKET.LocalPort]
	push	eax
	mov	eax, [network_free_ports]
	xchg	bl, bh
lock	bts	[eax], ebx
	pop	eax
	; remove it from the list first, changing pointers
	mov	ebx, [eax + SOCKET.NextPtr]
	mov	eax, [eax + SOCKET.PrevPtr]
	mov	[eax + SOCKET.NextPtr], ebx
	or	ebx, ebx
	jz	@f
	mov	[ebx + SOCKET.PrevPtr], eax

    @@: ; and finally free the memory structure used
	stdcall kernel_free, [sockAddr]
	ret

  .error:
	DEBUGF	1, "K :   failed\n"
	ret
endp

;; Get socket structure address by its number
; Scan through sockets list to find the socket with specified number.
; This proc uses SOCKET.PID indirectly to check if socket is owned by
; calling process.
;
; @param sockNum is a socket number
; @return socket structure address or 0 (not found) in EAX
;;
proc net_socket_num_to_addr stdcall uses ebx ecx, sockNum:DWORD
	mov	eax, [sockNum]
	; check if we got something similar to socket number
	or	eax, eax
	jz	.error

	; scan through sockets list
	mov	ebx, net_sockets
	;mov     ecx, [TASK_BASE]
	;mov     ecx, [ecx + TASKDATA.pid]
  .next_socket:
	mov	ebx, [ebx + SOCKET.NextPtr]
	or	ebx, ebx
	jz	.error
	cmp	[ebx + SOCKET.Number], eax
	jne	.next_socket
	;cmp     [ebx + SOCKET.PID], ecx
	;jne     .next_socket

	; okay, we found the correct one
	mov	eax, ebx
	ret

  .error:
	xor	eax, eax
	ret
endp

;; Get socket number by its structure address
; Scan through sockets list to find the socket with specified address.
; This proc uses SOCKET.PID indirectly to check if socket is owned by
; calling process.
;
; @param sockAddr is a socket structure address
; @return socket number (SOCKET.Number) or 0 (not found) in EAX
;;
proc net_socket_addr_to_num stdcall uses ebx ecx, sockAddr:DWORD
	mov	eax, [sockAddr]
	; check if we got something similar to socket structure address
	or	eax, eax
	jz	.error

	; scan through sockets list
	mov	ebx, net_sockets
	;mov     ecx, [TASK_BASE]
	;mov     ecx, [ecx + TASKDATA.pid]
  .next_socket:
	mov	ebx, [ebx + SOCKET.NextPtr]
	or	ebx, ebx
	jz	.error
	cmp	ebx, eax
	jne	.next_socket
	;cmp     [ebx + SOCKET.PID], ecx
	;jne     .next_socket

	; okay, we found the correct one
	mov	eax, [ebx + SOCKET.Number]
	ret

  .error:
	xor	eax, eax
	ret
endp

;; [53.9] Check if local port is used by any socket in the system.
; Scan through sockets list, checking SOCKET.LocalPort.
; Useful when you want a to generate a unique local port number.
; This proc doesn't guarantee that after calling it and trying to use
; the port reported being free in calls to socket_open/socket_open_tcp it'll
; still be free or otherwise it'll still be used if reported being in use.
;
; @param BX is a port number
; @return 1 (port is free) or 0 (port is in use) in EAX
;;
proc is_localport_unused stdcall
	movzx	ebx, bx
	mov	eax, [network_free_ports]
	bt	[eax], ebx
	setc	al
	movzx	eax, al
	ret
endp

;======================================
set_local_port:
;--------------------------------------
;? Set local port in socket structure.
;--------------------------------------
;> eax -> struct SOCKET
;> bx = local port, or 0 if the kernel must select it itself
;--------------------------------------
;< CF set on error / cleared on success
;< [eax+SOCKET.LocalPort] filled on success
;======================================
; 0. Prepare: save registers, make eax point to ports table, expand port to ebx.
	push	eax ecx
	mov	eax, [network_free_ports]
	movzx	ebx, bx
; 1. Test, whether the kernel should choose port itself. If no, proceed to 5.
	test	ebx, ebx
	jnz	.given
; 2. Yes, it should. Set ecx = limit of table, eax = start value
	lea	ecx, [eax+0x10000/8]
	add	eax, [network_free_hint]
; 3. First scan loop: from free hint to end of table.
.scan1:
; 3a. For each dword, find bit set to 1
	bsf	ebx, [eax]
	jz	.next1
; 3b. If such bit has been found, atomically test again and clear it.
lock	btr	[eax], ebx
; 3c. If the bit was still set (usual case), we have found and reserved one port.
; Proceed to 6.
	jc	.found
; 3d. Otherwise, someone has reserved it between bsf and btr, so retry search.
	jmp	.scan1
.next1:
; 3e. All bits are cleared, so advance to next dword.
	add	eax, 4
; 3f. Check limit and continue loop.
	cmp	eax, ecx
	jb	.scan1
; 4. Second scan loop: from port 1024 (start of non-system ports) to free hint.
	mov	eax, [network_free_ports]
	mov	ecx, eax
	add	ecx, [network_free_hint]
	add	eax, 1024/8
; 4a. Test whether there is something to scan.
	cmp	eax, ecx
	jae	.fail
; 4b. Enter the loop, the process is same as for 3.
.scan2:
	bsf	ebx, [eax]
	jz	.next2
lock	btr	[eax], ebx
	jc	.found
	jmp	.scan2
.next2:
	add	eax, 4
	cmp	eax, ecx
	jb	.scan2
; 4c. None found. Fail.
.fail:
	pop	ecx eax
	stc
	ret
; 5. No, the kernel should reserve selected port.
.given:
; 5a. Atomically test old value and clear bit.
lock	btr	[eax], ebx
; 5b. If the bit was set, reservation is successful. Proceed to 8.
	jc	.set
; 5c. Otherwise, fail.
	jmp	.fail
.found:
; 6. We have found the bit set to 1, convert the position to port number.
	sub	eax, [network_free_ports]
	lea	ebx, [ebx+eax*8]
; 7. Update free hint.
	add	eax, 4
	cmp	eax, 65536/8
	jb	@f
	mov	eax, 1024/8
@@:
	mov	[network_free_hint], eax
.set:
; 8. Restore eax, set SOCKET.LocalPort and return.
	pop	ecx eax
	xchg	bl, bh	; Intel -> network byte order
	mov	[eax + SOCKET.LocalPort], bx
	clc
	ret

;; [53.0] Open DGRAM socket (connectionless, unreliable)
;
; @param BX is local port number
; @param CX is remote port number
; @param EDX is remote IP address
; @return socket number or -1 (error) in EAX
;;
proc socket_open stdcall
	call	net_socket_alloc
	or	eax, eax
	jz	.error

	DEBUGF	1, "K : socket_open (0x%x)\n", eax

	push	eax

	call	set_local_port
	jc	.error.free
	xchg	ch, cl
	mov	[eax + SOCKET.RemotePort], cx
	mov	ebx, [stack_ip]
	mov	[eax + SOCKET.LocalIP], ebx
	mov	[eax + SOCKET.RemoteIP], edx

	;pop     eax      ; Get the socket number back, so we can return it
	stdcall net_socket_addr_to_num
	ret

  .error.free:
	stdcall	net_socket_free;, eax

  .error:
	DEBUGF	1, "K : socket_open (fail)\n"
	or	eax, -1
	ret
endp

;; [53.5] Open STREAM socket (connection-based, sequenced, reliable, two-way)
;
; @param BX is local port number
; @param CX is remote port number
; @param EDX is remote IP address
; @param ESI is open mode (SOCKET_ACTIVE, SOCKET_PASSIVE)
; @return socket number or -1 (error) in EAX
;;
proc socket_open_tcp stdcall
local sockAddr dd ?

	cmp	esi, SOCKET_PASSIVE
	jne	.skip_port_check

	push	ebx
	mov	eax, ebx
	xchg	al, ah
	mov	ebx, net_sockets

  .next_socket:
	mov	ebx, [ebx + SOCKET.NextPtr]
	or	ebx, ebx
	jz	.last_socket
	cmp	[ebx + SOCKET.TCBState], TCB_LISTEN
	jne	.next_socket
	cmp	[ebx + SOCKET.LocalPort], ax
	jne	.next_socket

	xchg	al, ah
	DEBUGF	1, "K : error: port %u is listened by 0x%x\n", ax, ebx
	pop	ebx
	jmp	.error

  .last_socket:
	pop	ebx

  .skip_port_check:
	call	net_socket_alloc
	or	eax, eax
	jz	.error

	DEBUGF	1, "K : socket_open_tcp (0x%x)\n", eax

	mov	[sockAddr], eax

	; TODO - check this works!
	;mov     [eax + SOCKET.wndsizeTimer], 0     ; Reset the window timer.

	call	set_local_port
	jc	.error.free
	xchg	ch, cl
	mov	[eax + SOCKET.RemotePort], cx
	mov	[eax + SOCKET.OrigRemotePort], cx
	mov	ebx, [stack_ip]
	mov	[eax + SOCKET.LocalIP], ebx
	mov	[eax + SOCKET.RemoteIP], edx
	mov	[eax + SOCKET.OrigRemoteIP], edx

	mov	ebx, TCB_LISTEN
	cmp	esi, SOCKET_PASSIVE
	je	@f
	mov	ebx, TCB_SYN_SENT
    @@: mov	[eax + SOCKET.TCBState], ebx		; Indicate the state of the TCB

	cmp	ebx, TCB_LISTEN
	je	.exit

	; Now, if we are in active mode, then we have to send a SYN to the specified remote port
	mov	eax, EMPTY_QUEUE
	call	dequeue
	cmp	ax, NO_BUFFER
	je	.exit

	push	eax

	mov	bl, TH_SYN
	xor	ecx, ecx
	stdcall build_tcp_packet, [sockAddr]

	mov	eax, NET1OUT_QUEUE
	mov	edx, [stack_ip]
	mov	ecx, [sockAddr]
	cmp	edx, [ecx + SOCKET.RemoteIP]
	jne	.not_local
	mov	eax, IPIN_QUEUE

  .not_local:
	; Send it.
	pop	ebx
	call	queue

	mov	esi, [sockAddr]

	; increment SND.NXT in socket
	add	esi, SOCKET.SND_NXT
	call	inc_inet_esi

  .exit:
	; Get the socket number back, so we can return it
	stdcall net_socket_addr_to_num, [sockAddr]
	ret

  .error.free:
	stdcall	net_socket_free, eax

  .error:
	DEBUGF	1, "K : socket_open_tcp (fail)\n"
	or	eax, -1
	ret
endp

;; [53.1] Close DGRAM socket
;
; @param EBX is socket number
; @return 0 (closed successfully) or -1 (error) in EAX
;;
proc socket_close stdcall
	DEBUGF	1, "K : socket_close (0x%x)\n", ebx
	stdcall net_socket_num_to_addr, ebx
	or	eax, eax
	jz	.error

	stdcall net_socket_free, eax

	xor	eax, eax
	ret

  .error:
	DEBUGF	1, "K : socket_close (fail)\n"
	or	eax, -1
	ret
endp

;; [53.8] Close STREAM socket
; Closing TCP sockets takes time, so when you get successful return code
; from this function doesn't always mean that socket is actually closed.
;
; @param EBX is socket number
; @return 0 (closed successfully) or -1 (error) in EAX
;;
proc socket_close_tcp stdcall
local sockAddr dd ?

	DEBUGF	1, "K : socket_close_tcp (0x%x)\n", ebx
	; first, remove any resend entries
	pusha

	mov	esi, resendQ
	mov	ecx, 0

  .next_resendq:
	cmp	ecx, NUMRESENDENTRIES
	je	.last_resendq	    ; None left
	cmp	[esi + 4], ebx
	je	@f		    ; found one
	inc	ecx
	add	esi, 8
	jmp	.next_resendq

    @@: mov	dword[esi + 4], 0
	inc	ecx
	add	esi, 8
	jmp	.next_resendq

  .last_resendq:
	popa

	stdcall net_socket_num_to_addr, ebx
	or	eax, eax
	jz	.error

	mov	ebx, eax
	mov	[sockAddr], eax

	cmp	[ebx + SOCKET.TCBState], TCB_LISTEN
	je	.destroy_tcb
	cmp	[ebx + SOCKET.TCBState], TCB_SYN_SENT
	je	.destroy_tcb
	cmp	[ebx + SOCKET.TCBState], TCB_CLOSED
	je	.destroy_tcb

	; Now construct the response, and queue for sending by IP
	mov	eax, EMPTY_QUEUE
	call	dequeue
	cmp	ax, NO_BUFFER
	je	.error

	push	eax

	mov	bl, TH_FIN+TH_ACK
	xor	ecx, ecx
	xor	esi, esi
	stdcall build_tcp_packet, [sockAddr]

	mov	 ebx, [sockAddr]
	; increament SND.NXT in socket
	lea	esi, [ebx + SOCKET.SND_NXT]
	call	inc_inet_esi

	; Get the socket state
	mov	eax, [ebx + SOCKET.TCBState]
	cmp	eax, TCB_SYN_RECEIVED
	je	.fin_wait_1
	cmp	eax, TCB_ESTABLISHED
	je	.fin_wait_1

	; assume CLOSE WAIT
	; Send a fin, then enter last-ack state
	mov	[ebx + SOCKET.TCBState], TCB_LAST_ACK
	jmp	.send

  .fin_wait_1:
	; Send a fin, then enter finwait2 state
	mov	[ebx + SOCKET.TCBState], TCB_FIN_WAIT_1

  .send:
	mov	eax, NET1OUT_QUEUE
	mov	edx, [stack_ip]
	mov	ecx, [sockAddr]
	cmp	edx, [ecx + SOCKET.RemoteIP]
	jne	.not_local
	mov	eax, IPIN_QUEUE

  .not_local:
	; Send it.
	pop	ebx
	call	queue
	jmp	.exit

  .destroy_tcb:

	; Clear the socket variables
	stdcall net_socket_free, ebx

  .exit:
	xor	eax, eax
	ret

  .error:
	DEBUGF	1, "K : socket_close_tcp (fail)\n"
	or	eax, -1
	ret
endp

;; [53.2] Poll socket
;
; @param EBX is socket number
; @return count or bytes in rx buffer or 0 (error) in EAX
;;
proc socket_poll stdcall
;        DEBUGF  1, "socket_poll(0x%x)\n", ebx
	stdcall net_socket_num_to_addr, ebx
	or	eax, eax
	jz	.error

	mov	eax, [eax + SOCKET.rxDataCount]
	ret

  .error:
	xor	eax, eax
	ret
endp

;; [53.6] Get socket TCB state
;
; @param EBX is socket number
; @return socket TCB state or 0 (error) in EAX
;;
proc socket_status stdcall
;;       DEBUGF  1, "socket_status(0x%x)\n", ebx
	stdcall net_socket_num_to_addr, ebx
	or	eax, eax
	jz	.error

	mov	eax, [eax + SOCKET.TCBState]
	ret

  .error:
	xor	eax, eax
	ret
endp

;; [53.3] Get one byte from rx buffer
; This function can return 0 in two cases: if there's one byte read and
; non left, and if an error occured. Behavior should be changed and function
; shouldn't be used for now. Consider using [53.11] instead.
;
; @param EBX is socket number
; @return number of bytes left in rx buffer or 0 (error) in EAX
; @return byte read in BL
;;
proc socket_read stdcall
;        DEBUGF  1, "socket_read(0x%x)\n", ebx
	stdcall net_socket_num_to_addr, ebx
	or	eax, eax
	jz	.error

	lea	ebx, [eax + SOCKET.lock]
	call	wait_mutex

	mov	ebx, eax
	mov	eax, [ebx + SOCKET.rxDataCount] 	; get count of bytes
	test	eax, eax
	jz	.error_release

	dec	eax
	mov	esi, ebx				; esi is address of socket
	mov	[ebx + SOCKET.rxDataCount], eax 	; store new count
	movzx	eax, byte[ebx + SOCKET.rxData]		; get the byte

	mov	ecx, SOCKETBUFFSIZE - SOCKET.rxData - 1
	lea	edi, [esi + SOCKET.rxData]
	lea	esi, [edi + 1]
	cld
	push	ecx
	shr	ecx, 2
	rep	movsd
	pop	ecx
	and	ecx, 3
	rep	movsb

	mov	[ebx + SOCKET.lock], 0
	mov	ebx, eax

	ret

  .error_release:
	mov	[ebx + SOCKET.lock], 0
  .error:
	xor	ebx, ebx
	ret
endp

;; [53.11] Get specified number of bytes from rx buffer
; Number of bytes in rx buffer can be less than requested size. In this case,
; only available number of bytes is read.
; This function can return 0 in two cases: if there's no data to read, and if
; an error occured. Behavior should be changed.
;
; @param EBX is socket number
; @param ECX is pointer to application buffer
; @param EDX is application buffer size (number of bytes to read)
; @return number of bytes read or 0 (error) in EAX
;;
proc socket_read_packet stdcall
;        DEBUGF  1, "socket_read_packet(0x%x)\n", ebx
	stdcall net_socket_num_to_addr, ebx		   ; get real socket address
	or	eax, eax
	jz	.error

	lea	ebx, [eax + SOCKET.lock]
	call	wait_mutex

	mov	ebx, eax
	mov	eax, [ebx + SOCKET.rxDataCount] 	   ; get count of bytes
	test	eax, eax				   ; if count of bytes is zero..
	jz	.exit					   ; exit function (eax will be zero)

	test	edx, edx				   ; if buffer size is zero, copy all data
	jz	.copy_all_bytes
	cmp	edx, eax				   ; if buffer size is larger then the bytes of data, copy all data
	jge	.copy_all_bytes

	sub	eax, edx				   ; store new count (data bytes in buffer - bytes we're about to copy)
	mov	[ebx + SOCKET.rxDataCount], eax 	   ;
	push	eax
	mov	eax, edx				   ; number of bytes we want to copy must be in eax
	call	.start_copy				   ; copy to the application

	mov	esi, ebx				   ; now we're going to copy the remaining bytes to the beginning
	add	esi, SOCKET.rxData			   ; we dont need to copy the header
	mov	edi, esi				   ; edi is where we're going to copy to
	add	esi, edx				   ; esi is from where we copy
	pop	ecx					   ; count of bytes we have left
	push	ecx					   ; push it again so we can re-use it later
	shr	ecx, 2					   ; divide eax by 4
	cld
	rep	movsd					   ; copy all full dwords
	pop	ecx
	and	ecx, 3
	rep	movsb					   ; copy remaining bytes

  .exit:
	mov	[ebx + SOCKET.lock], 0
	ret						   ; at last, exit

  .error:
	xor	eax, eax
	ret

  .copy_all_bytes:
	xor	esi, esi
	mov	[ebx + SOCKET.rxDataCount], esi 	   ; store new count (zero)
	call	.start_copy
	mov	[ebx + SOCKET.lock], 0
	ret

  .start_copy:
	mov	edi, ecx
	mov	esi, ebx
	add	esi, SOCKET.rxData			   ; we dont need to copy the header
	mov	ecx, eax				   ; eax is count of bytes
	push	ecx
	shr	ecx, 2					   ; divide eax by 4
	cld						   ; copy all full dwords
	rep	movsd
	pop	ecx
	and	ecx, 3
	rep	movsb					   ; copy the rest bytes
	retn						   ; exit, or go back to shift remaining bytes if any
endp

;; [53.4] Send data through DGRAM socket
;
; @param EBX is socket number
; @param ECX is application data size (number of bytes to send)
; @param EDX is pointer to application data buffer
; @return 0 (sent successfully) or -1 (error) in EAX
;;
proc socket_write stdcall
;        DEBUGF  1, "socket_write(0x%x)\n", ebx
	stdcall net_socket_num_to_addr, ebx		   ; get real socket address
	or	eax, eax
	jz	.error

	mov	ebx, eax

	mov	eax, EMPTY_QUEUE
	call	dequeue
	cmp	ax, NO_BUFFER
	je	.error

	; Save the queue entry number
	push	eax

	; save the pointers to the data buffer & size
	push	edx
	push	ecx

	; convert buffer pointer eax to the absolute address
	mov	ecx, IPBUFFSIZE
	mul	ecx
	add	eax, IPbuffs

	mov	edx, eax

	; So, ebx holds the socket ptr, edx holds the IPbuffer ptr

	; Fill in the IP header (some data is in the socket descriptor)
	mov	eax, [ebx + SOCKET.LocalIP]
	mov	[edx + IP_PACKET.SourceAddress], eax
	mov	eax, [ebx + SOCKET.RemoteIP]
	mov	[edx + IP_PACKET.DestinationAddress], eax

	mov	[edx + IP_PACKET.VersionAndIHL], 0x45
	mov	[edx + IP_PACKET.TypeOfService], 0

	pop	eax		      ; Get the UDP data length
	push	eax

	add	eax, 20 + 8	      ; add IP header and UDP header lengths
	xchg	al, ah
	mov	[edx + IP_PACKET.TotalLength], ax
	xor	eax, eax
	mov	[edx + IP_PACKET.Identification], ax
	mov	[edx + IP_PACKET.FlagsAndFragmentOffset], 0x0040
	mov	[edx + IP_PACKET.TimeToLive], 0x20
	mov	[edx + IP_PACKET.Protocol], PROTOCOL_UDP

	; Checksum left unfilled
	mov	[edx + IP_PACKET.HeaderChecksum], ax

	; Fill in the UDP header (some data is in the socket descriptor)
	mov	ax, [ebx + SOCKET.LocalPort]
	mov	[edx + 20 + UDP_PACKET.SourcePort], ax

	mov	ax, [ebx + SOCKET.RemotePort]
	mov	[edx + 20 + UDP_PACKET.DestinationPort], ax

	pop	eax
	push	eax

	add	eax, 8
	xchg	al, ah
	mov	[edx + 20 + UDP_PACKET.Length], ax

	; Checksum left unfilled
	xor	eax, eax
	mov	[edx + 20 + UDP_PACKET.Checksum], ax

	pop	ecx		     ; count of bytes to send
	mov	ebx, ecx	     ; need the length later
	pop	eax		     ; get callers ptr to data to send

	; Get the address of the callers data
	mov	edi, [TASK_BASE]
	add	edi, TASKDATA.mem_start
	add	eax, [edi]
	mov	esi, eax

	mov	edi, edx
	add	edi, 28
	cld
	rep	movsb		    ; copy the data across

	; we have edx as IPbuffer ptr.
	; Fill in the UDP checksum
	; First, fill in pseudoheader
	mov	eax, [edx + IP_PACKET.SourceAddress]
	mov	[pseudoHeader], eax
	mov	eax, [edx + IP_PACKET.DestinationAddress]
	mov	[pseudoHeader + 4], eax
	mov	word[pseudoHeader + 8], PROTOCOL_UDP shl 8 + 0	    ; 0 + protocol
	add	ebx, 8
	mov	eax, ebx
	xchg	al, ah
	mov	[pseudoHeader + 10], ax

	mov	eax, pseudoHeader
	mov	[checkAdd1], eax
	mov	[checkSize1], word 12
	mov	eax, edx
	add	eax, 20
	mov	[checkAdd2], eax
	mov	eax, ebx
	mov	[checkSize2], ax      ; was eax!! mjh 8/7/02

	call	checksum

	; store it in the UDP checksum ( in the correct order! )
	mov	ax, [checkResult]

	; If the UDP checksum computes to 0, we must make it 0xffff
	; (0 is reserved for 'not used')
	test	ax, ax
	jnz	@f
	mov	ax, 0xffff

    @@: xchg	al, ah
	mov	[edx + 20 + UDP_PACKET.Checksum], ax

	; Fill in the IP header checksum
	GET_IHL ecx,edx 	     ; get IP-Header length
	stdcall checksum_jb,edx,ecx  ; buf_ptr, buf_size
	xchg	al, ah
	mov	[edx + IP_PACKET.HeaderChecksum], ax

	; Check destination IP address.
	; If it is the local host IP, route it back to IP_RX

	pop	ebx

	mov	eax, NET1OUT_QUEUE
	mov	ecx, [edx + SOCKET.RemoteIP]
	mov	edx, [stack_ip]
	cmp	edx, ecx
	jne	.not_local
	mov	eax, IPIN_QUEUE

  .not_local:
	; Send it.
	call	queue

	xor	eax, eax
	ret

  .error:
	or	eax, -1
	ret
endp

;; [53.7] Send data through STREAM socket
;
; @param EBX is socket number
; @param ECX is application data size (number of bytes to send)
; @param EDX is pointer to application data buffer
; @return 0 (sent successfully) or -1 (error) in EAX
;;
proc socket_write_tcp stdcall
local sockAddr dd ?

;        DEBUGF  1, "socket_write_tcp(0x%x)\n", ebx
	stdcall net_socket_num_to_addr, ebx
	or	eax, eax
	jz	.error

	mov	ebx, eax
	mov	[sockAddr], ebx

	; If the sockets window timer is nonzero, do not queue packet
	cmp	[ebx + SOCKET.wndsizeTimer], 0
	jne	.error

	mov	eax, EMPTY_QUEUE
	call	dequeue
	cmp	ax, NO_BUFFER
	je	.error

	push	eax

	; Get the address of the callers data
	mov	edi, [TASK_BASE]
	add	edi, TASKDATA.mem_start
	add	edx, [edi]
	mov	esi, edx

	pop	eax
	push	eax

	push	ecx
	mov	bl, TH_ACK
	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	edx, [stack_ip]
	mov	ecx, [sockAddr]
	cmp	edx, [ecx + SOCKET.RemoteIP]
	jne	.not_local
	mov	eax, IPIN_QUEUE

  .not_local:
	pop	ecx
	push	ebx		    ; save ipbuffer number

	call	queue

	mov	esi, [sockAddr]

	; increament SND.NXT in socket
	; Amount to increment by is in ecx
	add	esi, SOCKET.SND_NXT
	call	add_inet_esi

	pop	ebx

	; Copy the IP buffer to a resend queue
	; If there isn't one, dont worry about it for now
	mov	esi, resendQ
	mov	ecx, 0

  .next_resendq:
	cmp	ecx, NUMRESENDENTRIES
	je	.exit		   ; None found
	cmp	dword[esi + 4], 0
	je	@f		   ; found one
	inc	ecx
	add	esi, 8
	jmp	.next_resendq

    @@: push	ebx

	; OK, we have a buffer descriptor ptr in esi.
	; resend entry # in ecx
	;  Populate it
	;  socket #
	;  retries count
	;  retry time
	;  fill IP buffer associated with this descriptor

	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

    @@: 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
	mul	ecx
	add	eax, IPbuffs
	mov	esi, eax

	; do copy
	mov	ecx, IPBUFFSIZE
	cld
	rep	movsb

  .exit:
	xor	eax, eax
	ret

  .error:
	or	eax, -1
	ret
endp