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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2011. All rights reserved.    ;;
;; Distributed under terms of the GNU General Public License       ;;
;;                                                                 ;;
;;    Written by hidnplayr@kolibrios.org,                          ;;
;;     and Clevermouse.                                            ;;
;;                                                                 ;;
;;       Based on code by mike.dld                                 ;;
;;                                                                 ;;
;;         GNU GENERAL PUBLIC LICENSE                              ;;
;;          Version 2, June 1991                                   ;;
;;                                                                 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 2303 $
 
 
virtual at 0
 
	SOCKET:
	.NextPtr		dd ? ; pointer to next socket in list
	.PrevPtr		dd ? ; pointer to previous socket in list
	.Number 		dd ? ; socket number
 
	.lock			dd ? ; lock mutex
 
	.PID			dd ? ; application process id
	.Domain 		dd ? ; INET/UNIX/..
	.Type			dd ? ; RAW/STREAM/DGRAP
	.Protocol		dd ? ; ICMP/IPv4/ARP/TCP/UDP
	.errorcode		dd ?
 
	.options		dd ?
	.state			dd ?
	.backlog		dw ? ; how many incomming connections that can be queued
 
	.snd_proc		dd ?
	.rcv_proc		dd ?
 
	.end:
end virtual
 
virtual at SOCKET.end
 
	IP_SOCKET:
	.LocalIP		rd 4
	.RemoteIP		rd 4
 
	.end:
end virtual
 
virtual at IP_SOCKET.end
 
	TCP_SOCKET:
 
	.LocalPort		dw ?
	.RemotePort		dw ?
 
	.t_state		dd ? ; TCB state
	.t_rxtshift		dd ?
	.t_rxtcur		dd ?
	.t_dupacks		dd ?
	.t_maxseg		dd ?
	.t_force		dd ?
	.t_flags		dd ?
 
;---------------
; RFC783 page 21
 
; send sequence
	.SND_UNA		dd ? ; sequence number of unack'ed sent Packets
	.SND_NXT		dd ? ; next send sequence number to use
	.SND_UP 		dd ?
	.SND_WL1		dd ? ; window minus one
	.SND_WL2		dd ? ;
	.ISS			dd ? ; initial send sequence number
	.SND_WND		dd ? ; send window
 
; receive sequence
	.RCV_WND		dw ? ; receive window
	.RCV_NXT		dd ? ; next receive sequence number to use
	.RCV_UP 		dd ?
	.IRS			dd ? ; initial receive sequence number
 
;---------------------
; Additional variables
 
; receive variables
	.RCV_ADV		dd ?
 
; retransmit variables
	.SND_MAX		dd ?
 
; congestion control
	.SND_CWND		dd ?
	.SND_SSTHRESH		dd ?
 
;----------------------
; Transmit timing stuff
	.t_idle 		dd ?
	.t_rtt			dd ?
	.t_rtseq		dd ?
	.t_srtt 		dd ?
	.t_rttvar		dd ?
	.t_rttmin		dd ?
	.max_sndwnd		dd ?
 
;-----------------
; Out-of-band data
	.t_oobflags		dd ?
	.t_iobc 		dd ?
	.t_softerror		dd ?
 
 
;---------
; RFC 1323
	.SND_SCALE		db ? ; Scale factor
	.RCV_SCALE		db ?
	.request_r_scale	db ?
	.requested_s_scale	dd ?
 
	.ts_recent		dd ?
	.ts_recent_age		dd ?
	.last_ack_sent		dd ?
 
 
;-------
; Timers
	.timer_retransmission	dw ? ; rexmt
	.timer_persist		dw ?
	.timer_keepalive	dw ? ; keepalive/syn timeout
	.timer_timed_wait	dw ? ; also used as 2msl timer
 
	.end:
end virtual
 
virtual at IP_SOCKET.end
 
	UDP_SOCKET:
 
	.LocalPort		dw ?
	.RemotePort		dw ?
	.firstpacket		db ?
 
	.end:
end virtual
 
virtual at IP_SOCKET.end
 
	ICMP_SOCKET:
 
	.Identifier		dw ?
 
	.end:
end virtual
 
struc	RING_BUFFER {
	.start_ptr		dd ? ; Pointer to start of buffer
	.end_ptr		dd ? ; pointer to end of buffer
	.read_ptr		dd ? ; Read pointer
	.write_ptr		dd ? ; Write pointer
	.size			dd ? ; Number of bytes buffered
	.end:
}
 
virtual at 0
 
	RING_BUFFER	RING_BUFFER
 
end virtual
 
virtual at TCP_SOCKET.end
 
 STREAM_SOCKET:
	.rcv	rd     RING_BUFFER.end/4
	.snd	rd     RING_BUFFER.end/4
	.end:
 
end virtual
 
struct	socket_queue_entry
	.data_ptr	dd ?
	.buf_ptr	dd ?
	.data_size	dd ?
	.size:
ends
 
 
SOCKETBUFFSIZE		equ 4096     ; in bytes
 
SOCKET_QUEUE_SIZE	equ 10	     ; maximum number ofincoming packets queued for 1 socket
; the incoming packet queue for sockets is placed in the socket struct itself, at this location from start
SOCKET_QUEUE_LOCATION	equ (SOCKETBUFFSIZE - SOCKET_QUEUE_SIZE*socket_queue_entry.size - queue.data)
 
uglobal
	net_sockets	rd 4
	last_socket_num dd ?
	last_UDP_port	dw ? ; These values give the number of the last used ephemeral port
	last_TCP_port	dw ? ;
endg
 
 
;-----------------------------------------------------------------
;
; SOCKET_init
;
;-----------------------------------------------------------------
macro	SOCKET_init {
 
	xor	eax, eax
	mov	edi, net_sockets
	mov	ecx, 5
	rep	stosd
 
       @@:
	pseudo_random eax
	cmp	ax, MIN_EPHEMERAL_PORT
	jb	@r
	cmp	ax, MAX_EPHEMERAL_PORT
	ja	@r
	mov	[last_UDP_port], ax
 
       @@:
	pseudo_random eax
	cmp	ax, MIN_EPHEMERAL_PORT
	jb	@r
	cmp	ax, MAX_EPHEMERAL_PORT
	ja	@r
	mov	[last_TCP_port], ax
 
}
 
 
;-----------------------------------------------------------------
;
; Socket API (function 74)
;
;-----------------------------------------------------------------
align 16
sock_sysfn_table:
	dd	SOCKET_open	; 0
	dd	SOCKET_close	; 1
	dd	SOCKET_bind	; 2
	dd	SOCKET_listen	; 3
	dd	SOCKET_connect	; 4
	dd	SOCKET_accept	; 5
	dd	SOCKET_send	; 6
	dd	SOCKET_receive	; 7
	dd	SOCKET_set_opt	; 8
	dd	SOCKET_get_opt	; 9
 
SOCKET_SYSFUNCS = ($ - sock_sysfn_table)/4
 
 
align 4
sys_socket:
	cmp	ebx, SOCKET_SYSFUNCS-1
	ja	@f
	jmp	dword [sock_sysfn_table + 4*ebx]
       @@:
	cmp	ebx, 255
	jz	SOCKET_debug
 
s_error:
	DEBUGF	1,"socket error\n"
	mov	dword [esp+32], -1
 
	ret
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_open
;
;  IN:  domain in ecx
;       type in edx
;       protocol in esi
;  OUT: eax is socket num, -1 on error
;
;-----------------------------------------------------------------
align 4
SOCKET_open:
 
	DEBUGF	1,"SOCKET_open: domain: %u, type: %u protocol: %x\n", ecx, edx, esi
 
	call	SOCKET_alloc
	jz	s_error
 
	mov	[esp+32], edi			; return socketnumber
 
	mov	[eax + SOCKET.Domain], ecx
	mov	[eax + SOCKET.Type], edx
	mov	[eax + SOCKET.Protocol], esi
 
	cmp	ecx, AF_INET4
	jne	.no_inet4
 
	cmp	edx, SOCK_DGRAM
	je	.udp
 
	cmp	edx, SOCK_STREAM
	je	.tcp
 
	cmp	edx, SOCK_RAW
	je	.raw
 
  .no_inet4:
	ret
 
align 4
  .raw:
	test	esi, esi       ; IP_PROTO_IP
	jz	.ip
 
	cmp	esi, IP_PROTO_ICMP
	je	.icmp
 
	cmp	esi, IP_PROTO_UDP
	je	.udp
 
	cmp	esi, IP_PROTO_TCP
	je	.tcp
 
	ret
 
align 4
  .udp:
	mov	[eax + SOCKET.Protocol], IP_PROTO_UDP
	mov	[eax + SOCKET.snd_proc], SOCKET_send_udp
	mov	[eax + SOCKET.rcv_proc], SOCKET_receive_dgram
	ret
 
align 4
  .tcp:
	mov	[eax + SOCKET.Protocol], IP_PROTO_TCP
	mov	[eax + SOCKET.snd_proc], SOCKET_send_tcp
	mov	[eax + SOCKET.rcv_proc], SOCKET_receive_tcp
 
 
	mov	[eax + TCP_SOCKET.t_maxseg], 1480	;;;;; FIXME
	ret
 
 
align 4
  .ip:
	mov	[eax + SOCKET.snd_proc], SOCKET_send_ip
	mov	[eax + SOCKET.rcv_proc], SOCKET_receive_dgram
	ret
 
 
align 4
  .icmp:
	mov	[eax + SOCKET.snd_proc], SOCKET_send_icmp
	mov	[eax + SOCKET.rcv_proc], SOCKET_receive_dgram
	ret
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_bind
;
;  IN:  socket number in ecx
;       pointer to sockaddr struct in edx
;       length of that struct in esi
;  OUT: 0 on success
;
;-----------------------------------------------------------------
align 4
SOCKET_bind:
 
	DEBUGF	1,"socket_bind: socknum: %u sockaddr: %x, length: %u\n", ecx, edx, esi
 
	call	SOCKET_num_to_ptr
	jz	s_error
 
	cmp	esi, 2
	jb	s_error
 
	cmp	word [edx], AF_INET4
	je	.af_inet4
 
	cmp	word [edx], AF_UNIX
	je	.af_unix
 
	jmp	s_error
 
  .af_unix:
	; TODO: write code here
 
	mov	dword [esp+32], 0
	ret
 
  .af_inet4:
 
	DEBUGF	1,"af_inet4\n"
 
	cmp	esi, 6
	jb	s_error
 
	pushw	[edx + 2]
	pop	[eax + UDP_SOCKET.LocalPort]
 
	pushd	[edx + 4]
	pop	[eax + IP_SOCKET.LocalIP]
 
	DEBUGF	1,"local ip: %u.%u.%u.%u\n",\
	[eax + IP_SOCKET.LocalIP + 0]:1,[eax + IP_SOCKET.LocalIP + 1]:1,\
	[eax + IP_SOCKET.LocalIP + 2]:1,[eax + IP_SOCKET.LocalIP + 3]:1
 
	mov	dword [esp+32], 0
	ret
 
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_connect
;
;  IN:  socket number in ecx
;       pointer to sockaddr struct in edx
;       length of that struct in esi
;  OUT: 0 on success
;
;-----------------------------------------------------------------
align 4
SOCKET_connect:
 
	DEBUGF	1,"SOCKET_connect: socknum: %u sockaddr: %x, length: %u\n", ecx, edx, esi
 
	call	SOCKET_num_to_ptr
	jz	s_error
 
	cmp	esi, 8
	jb	s_error
 
	cmp	word [edx], AF_INET4
	je	.af_inet4
 
	jmp	s_error
 
  .af_inet4:
	cmp	[eax + IP_SOCKET.LocalIP], 0
	jne	@f
	push	[IP_LIST]
	pop	[eax + IP_SOCKET.LocalIP]
       @@:
 
	cmp	[eax + SOCKET.Protocol], IP_PROTO_UDP
	je	.udp
 
	cmp	[eax + SOCKET.Protocol], IP_PROTO_TCP
	je	.tcp
 
	cmp	[eax + SOCKET.Protocol], IP_PROTO_IP
	je	.ip
 
	cmp	[eax + SOCKET.Protocol], IP_PROTO_ICMP
	je	.ip
 
	jmp	s_error
 
align 4
  .udp:
	lea	ebx, [eax + SOCKET.lock]
	call	wait_mutex
 
	pushw	[edx + 2]
	pop	[eax + UDP_SOCKET.RemotePort]
 
	pushd	[edx + 4]
	pop	[eax + IP_SOCKET.RemoteIP]
 
	cmp	[eax + UDP_SOCKET.LocalPort], 0
	jne	@f
	call	SOCKET_find_port
       @@:
 
	mov	[eax + UDP_SOCKET.firstpacket], 0
 
	push	eax
	init_queue (eax + SOCKET_QUEUE_LOCATION)	; Set up data receiving queue
	pop	eax
 
	mov	[eax + SOCKET.lock], 0
	mov	dword [esp+32], 0
	ret
 
align 4
  .tcp:
	lea	ebx, [eax + SOCKET.lock]
	call	wait_mutex
 
	pushw	[edx + 2]
	pop	[eax + TCP_SOCKET.RemotePort]
 
	pushd	[edx + 4]
	pop	[eax + IP_SOCKET.RemoteIP]
 
	cmp	[eax + TCP_SOCKET.LocalPort], 0
	jne	@f
	call	SOCKET_find_port
       @@:
 
	mov	[eax + TCP_SOCKET.timer_persist], 0
	mov	[eax + TCP_SOCKET.t_state], TCPS_SYN_SENT
	push	[TCP_sequence_num]
	add	[TCP_sequence_num], 6400
	pop	[eax + TCP_SOCKET.ISS]
	mov	[eax + TCP_SOCKET.timer_keepalive], TCP_time_keep_init
 
	TCP_sendseqinit eax
 
;        mov     [ebx + TCP_SOCKET.timer_retransmission],   ;; todo: create macro to set retransmission timer
 
	mov	ebx, eax
 
	lea	eax, [ebx + STREAM_SOCKET.snd]
	call	SOCKET_ring_create
 
	lea	eax, [ebx + STREAM_SOCKET.rcv]
	call	SOCKET_ring_create
 
	mov	[ebx + SOCKET.lock], 0
 
	mov	eax, ebx
	call	TCP_output
 
	mov	dword [esp+32], 0
	ret
 
align 4
  .ip:
	lea	ebx, [eax + SOCKET.lock]
	call	wait_mutex
 
	pushd	[edx + 4]
	pop	[eax + IP_SOCKET.RemoteIP]
 
	push	eax
	init_queue (eax + SOCKET_QUEUE_LOCATION)	; Set up data receiving queue
	pop	eax
 
	mov	[eax + SOCKET.lock], 0
	mov	dword [esp+32], 0
	ret
 
 
;-----------------------------------------------------------------
;
; SOCKET_listen
;
;  IN:  socket number in ecx
;       backlog in edx
;  OUT: eax is socket num, -1 on error
;
;-----------------------------------------------------------------
align 4
SOCKET_listen:
 
	DEBUGF	1,"SOCKET_listen: socknum: %u backlog: %u\n", ecx, edx
 
	call	SOCKET_num_to_ptr
	jz	s_error
 
	cmp	[eax + SOCKET.Domain], AF_INET4
	jne	s_error
 
	cmp	[eax + SOCKET.Protocol], IP_PROTO_TCP
	jne	s_error
 
	cmp	[eax + TCP_SOCKET.LocalPort], 0
	je	s_error
 
	cmp	[eax + IP_SOCKET.LocalIP], 0
	jne	@f
	push	[IP_LIST]
	pop	[eax + IP_SOCKET.LocalIP]
       @@:
 
	cmp	edx, MAX_backlog
	jbe	@f
	mov	edx, MAX_backlog
       @@:
 
	mov	[eax + SOCKET.backlog], dx
	or	[eax + SOCKET.options], SO_ACCEPTCON
	mov	[eax + TCP_SOCKET.t_state], TCPS_LISTEN
 
	push	eax
	init_queue (eax + SOCKET_QUEUE_LOCATION)		; Set up sockets queue
	pop	eax
 
	mov	dword [esp+32], 0
 
	ret
 
 
;-----------------------------------------------------------------
;
; SOCKET_accept
;
;  IN:  socket number in ecx
;       addr in edx
;       addrlen in esi
;  OUT: eax is socket num, -1 on error
;
;-----------------------------------------------------------------
align 4
SOCKET_accept:
 
	DEBUGF	1,"SOCKET_accept: socknum: %u sockaddr: %x, length: %u\n", ecx, edx, esi
 
	call	SOCKET_num_to_ptr
	jz	s_error
 
	test	[eax + SOCKET.options], SO_ACCEPTCON
	jz	s_error
 
	cmp	[eax + SOCKET.Domain], AF_INET4
	jne	s_error
 
	cmp	[eax + SOCKET.Protocol], IP_PROTO_TCP
	jne	s_error
 
	get_from_queue (eax + SOCKET_QUEUE_LOCATION), MAX_backlog, 4, s_error
 
	mov	eax, [esi]
	call	SOCKET_ptr_to_num
	jz	s_error
	mov	[esp+32], eax
	ret
 
 
;-----------------------------------------------------------------
;
; SOCKET_close
;
;  IN:  socket number in ecx
;  OUT: eax is socket num, -1 on error
;
;-----------------------------------------------------------------
align 4
SOCKET_close:
 
	DEBUGF	1,"SOCKET_close: socknum: %u\n", ecx
 
	call	SOCKET_num_to_ptr
	jz	s_error
 
	cmp	[eax + SOCKET.Domain], AF_INET4
	jne	s_error
 
	cmp	[eax + SOCKET.Protocol], IP_PROTO_UDP
	je	.free
 
	cmp	[eax + SOCKET.Protocol], IP_PROTO_ICMP
	je	.free
 
	cmp	[eax + SOCKET.Protocol], IP_PROTO_IP
	je	.free
 
	cmp	[eax + SOCKET.Protocol], IP_PROTO_TCP
	je	.tcp
 
	jmp	s_error
 
  .tcp:
	cmp	[eax + TCP_SOCKET.t_state], TCPS_SYN_RECEIVED	 ; state must be LISTEN, SYN_SENT or CLOSED
	jb	.free
 
	call	TCP_output
	mov	dword [esp+32], 0
 
	ret
 
  .free:
	call	SOCKET_free
	mov	dword [esp+32], 0
 
	ret
 
 
;-----------------------------------------------------------------
;
; SOCKET_receive
;
;  IN:  socket number in ecx
;       addr to buffer in edx
;       length of buffer in esi
;       flags in edi
;  OUT: eax is number of bytes copied, -1 on error
;
;-----------------------------------------------------------------
align 4
SOCKET_receive:
 
	DEBUGF	1,"SOCKET_receive: socknum: %u bufaddr: %x, buflength: %u, flags: %x, ", ecx, edx, esi, edi
 
	call	SOCKET_num_to_ptr
	jz	s_error
 
	jmp	[eax + SOCKET.rcv_proc]
 
 
align 4
SOCKET_receive_dgram:
 
	DEBUGF	1,"SOCKET_receive: DGRAM\n"
 
	mov	ebx, esi
	mov	edi, edx					; addr to buffer
 
	get_from_queue (eax + SOCKET_QUEUE_LOCATION), SOCKET_QUEUE_SIZE, socket_queue_entry.size, s_error	; destroys esi and ecx
 
	mov	ecx, [esi + socket_queue_entry.data_size]
	DEBUGF	1,"Got %u bytes of data\n", ecx
 
	cmp	ecx, ebx
	ja	.too_small
 
	push	[esi + socket_queue_entry.buf_ptr]		; save the buffer addr so we can clear it later
	mov	esi, [esi + socket_queue_entry.data_ptr]
	DEBUGF	1,"Source buffer: %x, real addr: %x\n", [esp], esi
	mov	[esp+32+4], ecx 				; return number of bytes copied
 
; copy the data
	shr	ecx, 1
	jnc	.nb
	movsb
  .nb:
	shr	ecx, 1
	jnc	.nw
	movsw
  .nw:
	test	ecx, ecx
	jz	.nd
	rep	movsd
  .nd:
 
	call	kernel_free					; remove the packet
	ret
 
  .too_small:
 
	DEBUGF	1,"Buffer too small...\n"
	jmp	s_error
 
align 4
SOCKET_receive_tcp:
 
	DEBUGF	1,"SOCKET_receive: TCP\n"
 
	mov	ecx, esi
	mov	edi, edx
	add	eax, STREAM_SOCKET.rcv
	call	SOCKET_ring_read
	call	SOCKET_ring_free
 
	mov	[esp+32], ecx					; return number of bytes copied
 
	ret
 
 
;-----------------------------------------------------------------
;
; SOCKET_send
;
;
;  IN:  socket number in ecx
;       pointer to data in edx
;       datalength in esi
;       flags in edi
;  OUT: -1 on error
;
;-----------------------------------------------------------------
align 4
SOCKET_send:
 
	DEBUGF	1,"SOCKET_send: socknum: %u data ptr: %x, length: %u, flags: %x, ", ecx, edx, esi, edi
 
	call	SOCKET_num_to_ptr
	jz	s_error
 
	mov	ecx, esi
	mov	esi, edx
 
	jmp	[eax + SOCKET.snd_proc]
 
 
align 4
SOCKET_send_udp:
 
	DEBUGF	1,"SOCKET_send: UDP\n"
 
	call	UDP_output
 
	mov	[esp+32], eax
	ret
 
 
align 4
SOCKET_send_tcp:
 
	DEBUGF	1,"SOCKET_send: TCP\n"
 
	push	eax
	add	eax, STREAM_SOCKET.snd
	call	SOCKET_ring_write
	pop	eax
 
	call	TCP_output
 
	mov	[esp+32], eax
	ret
 
 
align 4
SOCKET_send_ip:
 
	DEBUGF	1,"type: IP\n"
 
	call	IPv4_output_raw
 
	mov	[esp+32], eax
	ret
 
align 4
SOCKET_send_icmp:
 
	DEBUGF	1,"SOCKET_send: ICMP\n"
 
	call	ICMP_output_raw
 
	mov	[esp+32], eax
	ret
 
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_get_options
;
;  IN:  ecx = socket number
;       edx = pointer to the options:
;               dd      level, optname, optval, optlen
;  OUT: -1 on error
;
; At moment, uses only pseudo-optname -2 for get last_ack_number for TCP.
; TODO: find best way to notify that send()'ed data were acknowledged
; Also pseudo-optname -3 is valid and returns socket state, one of TCPS_*.
;
;-----------------------------------------------------------------
align 4
SOCKET_get_opt:
 
	DEBUGF	1,"SOCKET_get_opt\n"
 
	call	SOCKET_num_to_ptr
	jz	s_error
 
	cmp	dword [edx], IP_PROTO_TCP
	jne	s_error
	cmp	dword [edx+4], -2
	je	@f
	cmp	dword [edx+4], -3
	jne	s_error
@@:
;        mov     eax, [edx+12]
;        test    eax, eax
;        jz      .fail
;        cmp     dword [eax], 4
;        mov     dword [eax], 4
;        jb      .fail
;        stdcall net_socket_num_to_addr, ecx
;        test    eax, eax
;        jz      .fail
;        ; todo: check that eax is really TCP socket
;        mov     ecx, [eax + TCP_SOCKET.last_ack_number]
;        cmp     dword [edx+4], -2
;        jz      @f
;        mov     ecx, [eax + TCP_SOCKET.state]
@@:
	mov	eax, [edx+8]
	test	eax, eax
	jz	@f
	mov	[eax], ecx
@@:
	mov	dword [esp+32], 0
	ret
 
 
 
 
align 4
SOCKET_set_opt:
 
	ret
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_debug
;
;  Copies socket variables to application buffer
;
;  IN:  ecx = socket number
;       edx = pointer to buffer
;
;  OUT: -1 on error
;-----------------------------------------------------------------
align 4
SOCKET_debug:
 
	DEBUGF	1,"socket_debug\n"
 
	call	SOCKET_num_to_ptr
	jz	s_error
 
	mov	esi, eax
	mov	edi, edx
	mov	ecx, SOCKETBUFFSIZE/4
	rep	movsd
 
	mov	dword [esp+32], 0
	ret
 
 
;-----------------------------------------------------------------
;
; SOCKET_find_port
;
; Fills in the local port number for TCP and UDP sockets
; This procedure always works because the number of sockets is
; limited to a smaller number then the number of possible ports
;
;  IN:  eax = socket pointer
;  OUT: /
;
;-----------------------------------------------------------------
align 4
SOCKET_find_port:
 
	DEBUGF	1,"SOCKET_find_port\n"
 
	push	ebx esi ecx
 
	cmp	[eax + SOCKET.Protocol], IP_PROTO_UDP
	je	.udp
 
	cmp	[eax + SOCKET.Protocol], IP_PROTO_TCP
	je	.tcp
 
	jmp	.error
 
  .done:
	mov	[eax + UDP_SOCKET.LocalPort], bx
  .error:
	pop	ecx esi ebx
	ret
 
  .udp:
	mov	bx, [last_UDP_port]
	call	.findit
	mov	[last_UDP_port], bx
	jmp	.done
 
  .tcp:
	mov	bx, [last_TCP_port]
	call	.findit
	mov	[last_TCP_port], bx
	jmp	.done
 
 
  .restart:
	mov	bx, MIN_EPHEMERAL_PORT
  .findit:
	inc	bx
 
	cmp	bx, MAX_EPHEMERAL_PORT
	jz	.restart
 
	call	SOCKET_check_port
	jz	.findit
 
	ret
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_check_port (to be used with AF_INET only!)
;
; Checks if a local port number is unused
; If the proposed port number is unused, it is filled in in the socket structure
;
;  IN:  eax = socket ptr (to find out if its a TCP/UDP socket)
;        bx = proposed socket number
;
;  OUT:  ZF = cleared on error
;
;-----------------------------------------------------------------
align 4
SOCKET_check_port:
 
	DEBUGF	1,"SOCKET_check_port\n"
 
	mov	ecx, [eax + SOCKET.Protocol]
	mov	esi, net_sockets
 
  .next_socket:
	mov	esi, [esi + SOCKET.NextPtr]
	or	esi, esi
	jz	.port_ok
 
	cmp	[esi + SOCKET.Protocol], ecx
	jne	.next_socket
 
	cmp	[esi + UDP_SOCKET.LocalPort], bx
	jne	.next_socket
 
	DEBUGF	1,"local port %u already in use\n", bx
	ret
 
  .port_ok:
	mov	[eax + UDP_SOCKET.LocalPort], bx
	or	bx, bx					; set the zero-flag
 
	ret
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_input
;
; Updates a (stateless) socket with received data
;
; Note: the mutex should already be set !
;
;  IN:  eax = socket ptr
;       ebx = pointer to device struct
;       ecx = data size
;       esi = ptr to data
;       [esp] = ptr to buf
;       [esp + 4] = buf size
;
;  OUT: /
;
;-----------------------------------------------------------------
align 4
SOCKET_input:
 
	DEBUGF	1,"SOCKET_input: socket=%x, data=%x size=%u\n", eax, esi, ecx
 
	mov	[esp+4], ecx
	push	esi
	mov	esi, esp
 
	add_to_queue (eax + SOCKET_QUEUE_LOCATION), SOCKET_QUEUE_SIZE, socket_queue_entry.size, SOCKET_input.full
 
	DEBUGF	1,"SOCKET_input: queued packet successfully\n"
	add	esp, socket_queue_entry.size
	mov	[eax + SOCKET.lock], 0
	jmp	SOCKET_notify_owner
 
  .full:
	DEBUGF	2,"SOCKET_input: socket %x is full!\n", eax
	mov	[eax + SOCKET.lock], 0
	call	kernel_free
	add	esp, 8
 
	ret
 
 
;--------------------------
;
; eax = ptr to ring struct (just a buffer of the right size)
;
align 4
SOCKET_ring_create:
 
	push	esi
	mov	esi, eax
 
	push	edx
	stdcall create_ring_buffer, SOCKET_MAXDATA, PG_SW
	pop	edx
 
	DEBUGF	1,"SOCKET_ring_created: %x\n", eax
	mov	[esi + RING_BUFFER.start_ptr], eax
	mov	[esi + RING_BUFFER.write_ptr], eax
	mov	[esi + RING_BUFFER.read_ptr], eax
	mov	[esi + RING_BUFFER.size], 0
	add	eax,  SOCKET_MAXDATA
	mov	[esi + RING_BUFFER.end_ptr], eax
	mov	eax, esi
	pop	esi
 
	ret
 
;-----------------------------------------------------------------
;
; SOCKET_ring_write
;
; Adds data to a stream socket, and updates write pointer and size
;
;  IN:  eax = ptr to ring struct
;       ecx = data size
;       esi = ptr to data
;
;  OUT: ecx = number of bytes stored
;
;-----------------------------------------------------------------
align 4
SOCKET_ring_write:
 
	DEBUGF	1,"SOCKET_ring_write: ringbuff=%x ptr=%x size=%u\n", eax, esi, ecx
 
	add	[eax + RING_BUFFER.size], ecx
	cmp	[eax + RING_BUFFER.size], SOCKET_MAXDATA
	ja	.too_large
 
  .copy:
	mov	edi, [eax + RING_BUFFER.write_ptr]
	DEBUGF	2,"SOCKET_ring_write: %u bytes from %x to %x\n", ecx, esi, edi
 
	push	ecx
	shr	ecx, 1
	jnc	.nb
	movsb
  .nb:
	shr	ecx, 1
	jnc	.nw
	movsw
  .nw:
	test	ecx, ecx
	jz	.nd
	rep	movsd
  .nd:
	pop	ecx
 
	cmp	edi, [eax + RING_BUFFER.end_ptr]
	jae	.wrap
	mov	[eax + RING_BUFFER.write_ptr], edi
 
	ret
 
  .wrap:
	sub	edi, SOCKET_MAXDATA
	mov	[eax + RING_BUFFER.write_ptr], edi
 
	ret
 
  .too_large:
	mov	ecx, SOCKET_MAXDATA				; calculate number of bytes available in buffer
	sub	ecx, [eax + RING_BUFFER.size]
	jae	.full
 
	mov	[eax + RING_BUFFER.size], SOCKET_MAXDATA	; update size, we will fill buffer completely
	jmp	.copy
 
  .full:
	DEBUGF	2,"SOCKET_ring_write: ring buffer is full!\n"
	xor	ecx, ecx
	ret
 
 
;-----------------------------------------------------------------
;
; SOCKET_ring_read
;
; reads the data, BUT DOES NOT CLEAR IT FROM MEMORY YET
;
;  IN:  eax = ptr to ring struct
;       ecx = buffer size
;       edi = ptr to buffer
;
;  OUT: ecx = number of bytes read
;
;-----------------------------------------------------------------
align 4
SOCKET_ring_read:
 
	DEBUGF	1,"SOCKET_ring_read: ringbuff=%x ptr=%x size=%u\n", eax, edi, ecx
 
	cmp	ecx, [eax + RING_BUFFER.size]
	ja	.less_data
 
  .copy:
	mov	esi, [eax + RING_BUFFER.read_ptr]
 
	DEBUGF	2,"SOCKET_ring_read: %u bytes from %x to %x\n", ecx, esi, edi
	push	ecx
	shr	ecx, 1
	jnc	.nb
	movsb
  .nb:
	shr	ecx, 1
	jnc	.nw
	movsw
  .nw:
	test	ecx, ecx
	jz	.nd
	rep	movsd
  .nd:
	pop	ecx
 
  .no_data_at_all:
	ret
 
  .less_data:
	mov	ecx, [eax + RING_BUFFER.size]
;        test    ecx, ecx
;        jz      .no_data_at_all
	jmp	.copy
 
 
;-----------------------------------------------------------------
;
; SOCKET_ring_free
;
; Free's some bytes from the ringbuffer
;
;  IN:  eax = ptr to ring struct
;       ecx = data size
;
;  OUT: ecx = number of bytes free-ed
;
;-----------------------------------------------------------------
align 4
SOCKET_ring_free:
 
	DEBUGF	1,"SOCKET_ring_free: %u bytes from ring %x\n", ecx, eax
 
	sub	[eax + RING_BUFFER.size], ecx
	jb	.sumthinwong
	add	[eax + RING_BUFFER.read_ptr], ecx
 
	mov	edx, [eax + RING_BUFFER.end_ptr]
	cmp	[eax + RING_BUFFER.read_ptr], edx
	jb	@f
	sub	[eax + RING_BUFFER.read_ptr], SOCKET_MAXDATA
       @@:
	ret
 
  .sumthinwong: 	       ; we could free all available bytes, but that would be stupid, i guess..
	add	[eax + RING_BUFFER.size], ecx
	xor	ecx, ecx
	ret
 
 
;-----------------------------------------------------------------
;
; SOCKET_notify_owner
;
; notify's the owner of a socket that something happened
;
;  IN:  eax = socket ptr
;  OUT: /
;
;-----------------------------------------------------------------
align 4
SOCKET_notify_owner:
 
	DEBUGF	1,"SOCKET_notify_owner: %x\n", eax
 
	call	SOCKET_check
	jz	.error
 
	push	eax ecx esi
 
; socket exists, now try to flag an event to the application
 
	mov	eax, [eax + SOCKET.PID]
	mov	ecx, 1
	mov	esi, TASK_DATA + TASKDATA.pid
 
       .next_pid:
	cmp	[esi], eax
	je	.found_pid
	inc	ecx
	add	esi, 0x20
	cmp	ecx, [TASK_COUNT]
	jbe	.next_pid
 
; PID not found, TODO: close socket!
 
	jmp	.error2
 
       .found_pid:
	shl	ecx, 8
	or	[ecx + SLOT_BASE + APPDATA.event_mask], EVENT_NETWORK
	mov	[check_idle_semaphore], 200
 
	DEBUGF	1,"SOCKET_notify_owner: succes!\n"
 
  .error2:
	pop	esi ecx eax
 
  .error:
 
	ret
 
 
;--------------------------------------------------------------------
;
; SOCKET_alloc
;
; 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).
;
; IN:  /
; OUT: eax = 0 on error, socket ptr otherwise
;      edi = socket number
;       ZF = cleared on error
;
;--------------------------------------------------------------------
align 4
SOCKET_alloc:
 
	push	ecx ebx
 
	stdcall kernel_alloc, SOCKETBUFFSIZE
	DEBUGF	1, "SOCKET_alloc: ptr=%x\n", eax
	or	eax, eax
	jz	.exit
 
; zero-initialize allocated memory
	push	eax edi
	mov	edi, eax
	mov	ecx, SOCKETBUFFSIZE / 4
	xor	eax, eax
	rep	stosd
	pop	edi eax
 
; set send-and receive procedures to return -1
	mov	[eax + SOCKET.snd_proc], s_error
	mov	[eax + SOCKET.rcv_proc], s_error
 
; find first free socket number and use it
	mov	ecx, [last_socket_num]
  .next_socket_number:
	inc	ecx
	jz	.next_socket_number	; avoid socket nr 0
	cmp	ecx, -1
	je	.next_socket_number	; avoid socket nr -1
	mov	ebx, net_sockets
  .next_socket:
	mov	ebx, [ebx + SOCKET.NextPtr]
	test	ebx, ebx
	jz	.last_socket
 
	cmp	[ebx + SOCKET.Number], ecx
	jne	.next_socket
	jmp	.next_socket_number
 
  .last_socket:
	mov	[last_socket_num], ecx
	mov	[eax + SOCKET.Number], ecx
	DEBUGF	1, "SOCKET_alloc: number=%u\n", ecx
	mov	edi, ecx
 
; Fill in PID
	mov	ebx, [TASK_BASE]
	mov	ebx, [ebx + TASKDATA.pid]
	mov	[eax + SOCKET.PID], ebx
 
; add socket to the list by re-arranging some pointers
	mov	ebx, [net_sockets + SOCKET.NextPtr]
 
	mov	[eax + SOCKET.PrevPtr], net_sockets
	mov	[eax + SOCKET.NextPtr], ebx
 
	test	ebx, ebx
	jz	@f
	add	ebx, SOCKET.lock	; lock the next socket
	call	wait_mutex
	sub	ebx, SOCKET.lock
	mov	[ebx + SOCKET.PrevPtr], eax
	mov	[ebx + SOCKET.lock], 0	; and unlock it again
       @@:
 
	mov	[net_sockets + SOCKET.NextPtr], eax
	or	eax, eax		; used to clear zero flag
  .exit:
	pop	ebx ecx
 
	ret
 
 
;----------------------------------------------------
;
; SOCKET_free
;
; Free socket data memory and remove socket from the list
;
; IN:  eax = socket ptr
; OUT: /
;
;----------------------------------------------------
align 4
SOCKET_free:
 
	DEBUGF	1, "SOCKET_free: %x\n", eax
 
	call	SOCKET_check
	jz	.error
 
	push	ebx
	lea	ebx, [eax + SOCKET.lock]
	call	wait_mutex
 
	DEBUGF	1, "SOCKET_free: freeing socket..\n"
 
	cmp	[eax + SOCKET.Domain], AF_INET4
	jnz	.no_tcp
 
	cmp	[eax + SOCKET.Protocol], IP_PROTO_TCP
	jnz	.no_tcp
 
	mov	ebx, eax
	stdcall kernel_free, [ebx + STREAM_SOCKET.rcv + RING_BUFFER.start_ptr]
	stdcall kernel_free, [ebx + STREAM_SOCKET.snd + RING_BUFFER.start_ptr]
	mov	eax, ebx
  .no_tcp:
 
	push	eax				; this will be passed to kernel_free
	mov	ebx, [eax + SOCKET.NextPtr]
	mov	eax, [eax + SOCKET.PrevPtr]
 
	DEBUGF	1, "SOCKET_free: linking socket %x to socket %x\n", eax, ebx
 
	test	eax, eax
	jz	@f
	mov	[eax + SOCKET.NextPtr], ebx
       @@:
 
	test	ebx, ebx
	jz	@f
	mov	[ebx + SOCKET.PrevPtr], eax
       @@:
 
	call	kernel_free
	pop	ebx
 
	DEBUGF	1, "SOCKET_free: success!\n"
 
  .error:
	ret
 
;------------------------------------
;
; SOCKET_fork
;
; Create a child socket
;
; IN:  socket nr in ebx
; OUT: child socket nr in eax
;
;-----------------------------------
align 4
SOCKET_fork:
 
	DEBUGF	1,"SOCKET_fork: %x\n", ebx
 
; Exit if backlog queue is full
	mov	eax, [ebx + SOCKET_QUEUE_LOCATION + queue.size]
	cmp	ax, [ebx + SOCKET.backlog]
	jae	.fail
 
; Allocate new socket
	call	SOCKET_alloc
	jz	.fail
 
	push	esi ecx edi
	push	eax
	mov	esi, esp
	add_to_queue (ebx + SOCKET_QUEUE_LOCATION), MAX_backlog, 4, .fail2
	pop	eax
 
; Copy structure from current socket to new
; We start at PID to preserve the socket num, and the 2 pointers at beginning of socket
	lea	esi, [ebx + SOCKET.PID]
	lea	edi, [eax + SOCKET.PID]
	mov	ecx, (SOCKET_QUEUE_LOCATION - SOCKET.PID + 3)/4
	rep	movsd
 
	and	[eax + SOCKET.options], not SO_ACCEPTCON
	pop	edi ecx esi
 
	ret
 
  .fail2:
	add	esp, 4+4+4
  .fail:
	DEBUGF	1,"SOCKET_fork: failed\n"
	xor	eax, eax
	ret
 
 
;---------------------------------------------------
;
; SOCKET_num_to_ptr
;
; Get socket structure address by its number
;
; IN:  ecx = socket number
; OUT: eax = 0 on error, socket ptr otherwise
;       ZF = set on error
;
;---------------------------------------------------
align 4
SOCKET_num_to_ptr:
 
	DEBUGF	1,"SOCKET_num_to_ptr: %u ", ecx
 
	mov	eax, net_sockets
 
  .next_socket:
	mov	eax, [eax + SOCKET.NextPtr]
	or	eax, eax
	jz	.error
	cmp	[eax + SOCKET.Number], ecx
	jne	.next_socket
 
	test	eax, eax
 
	DEBUGF	1,"(%x)\n", eax
  .error:
	ret
 
 
;---------------------------------------------------
;
; SOCKET_ptr_to_num
;
; Get socket number by its address
;
; IN:  eax = socket ptr
; OUT: eax = 0 on error, socket num otherwise
;       ZF = set on error
;
;---------------------------------------------------
align 4
SOCKET_ptr_to_num:
 
	DEBUGF	1,"SOCKET_ptr_to_num: %x ", eax
 
	call	SOCKET_check
	jz	.error
 
	mov	eax, [eax + SOCKET.Number]
 
	DEBUGF	1,"(%u)\n", eax
 
  .error:
	ret
 
 
;---------------------------------------------------
;
; SOCKET_check
;
; checks if the given value is really a socket ptr
;
; IN:  eax = socket ptr
; OUT: eax = 0 on error, unchanged otherwise
;       ZF = set on error
;
;---------------------------------------------------
align 4
SOCKET_check:
 
	DEBUGF	1,"SOCKET_check: %x\n", eax
 
	push	ebx
	mov	ebx, net_sockets
 
  .next_socket:
	mov	ebx, [ebx + SOCKET.NextPtr]
	or	ebx, ebx
	jz	.done
	cmp	ebx, eax
	jnz	.next_socket
 
  .done:
	mov	eax, ebx
	test	eax, eax
	pop	ebx
 
	ret
 
 
 
;---------------------------------------------------
;
; SOCKET_check_owner
;
; checks if the caller application owns the socket
;
; IN:  eax = socket ptr
; OUT:  ZF = true/false
;
;---------------------------------------------------
align 4
SOCKET_check_owner:
 
	DEBUGF	1,"SOCKET_check_owner: %x\n", eax
 
	push	ebx
	mov	ebx, [TASK_BASE]
	mov	ebx, [ecx + TASKDATA.pid]
	cmp	[eax + SOCKET.PID], ebx
	pop	 ebx
 
	ret
 
 
 
 
;------------------------------------------------------
;
; SOCKET_process_end
;
; Kernel calls this function when a certain process ends
; This function will check if the process had any open sockets
; And update them accordingly
;
; IN:  eax = pid
; OUT: /
;
;------------------------------------------------------
align 4
SOCKET_process_end:
 
	DEBUGF	1,"SOCKET_process_end: %x\n", eax
 
	push	ebx
	mov	ebx, net_sockets
 
  .next_socket:
 
	mov	ebx, [ebx + SOCKET.NextPtr]
  .test_socket:
	test	ebx, ebx
	jz	.done
 
	cmp	[ebx + SOCKET.PID], eax
	jne	.next_socket
 
	DEBUGF	1,"closing socket %x", eax, ebx
 
	mov	[ebx + SOCKET.PID], 0
 
	cmp	[ebx + SOCKET.Protocol], IP_PROTO_UDP
	je	.udp
 
	cmp	[ebx + SOCKET.Protocol], IP_PROTO_TCP
	je	.tcp
 
	jmp	.next_socket	; kill all sockets for given PID
 
  .udp:
	mov	eax, ebx
	mov	ebx, [ebx + SOCKET.NextPtr]
	call	SOCKET_free
	jmp	.test_socket
 
  .tcp:
 
	;;; TODO
 
	jmp	.next_socket
 
  .done:
	pop	ebx
 
	ret
 
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_is_connecting
;
;  IN:  eax = socket ptr
;  OUT: /
;
;-----------------------------------------------------------------
 
align 4
SOCKET_is_connecting:
 
 
	and	[eax + SOCKET.options], not (SS_ISCONNECTED + SS_ISDISCONNECTING + SS_ISCONFIRMING)
	or	[eax + SOCKET.options], SS_ISCONNECTING
 
	jmp	SOCKET_notify_owner
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_is_connected
;
;  IN:  eax = socket ptr
;  OUT: /
;
;-----------------------------------------------------------------
 
align 4
SOCKET_is_connected:
 
 
	and	[eax + SOCKET.options], not (SS_ISCONNECTING + SS_ISDISCONNECTING + SS_ISCONFIRMING)
	or	[eax + SOCKET.options], SS_ISCONNECTED
 
	jmp	SOCKET_notify_owner
 
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_is_disconnecting
;
;  IN:  eax = socket ptr
;  OUT: /
;
;-----------------------------------------------------------------
 
align 4
SOCKET_is_disconnecting:
 
	and	[eax + SOCKET.options], not (SS_ISCONNECTING)
	or	[eax + SOCKET.options], SS_ISDISCONNECTING + SS_CANTRCVMORE + SS_CANTSENDMORE
 
	jmp	SOCKET_notify_owner
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_is_disconnected
;
;  IN:  eax = socket ptr
;  OUT: /
;
;-----------------------------------------------------------------
 
align 4
SOCKET_is_disconnected:
 
	and	[eax + SOCKET.options], not (SS_ISCONNECTING + SS_ISCONNECTED + SS_ISDISCONNECTING)
	or	[eax + SOCKET.options], SS_CANTRCVMORE + SS_CANTSENDMORE
 
	jmp	SOCKET_notify_owner
 
 
;-----------------------------------------------------------------
;
; SOCKET_cant_recv_more
;
;  IN:  eax = socket ptr
;  OUT: /
;
;-----------------------------------------------------------------
 
align 4
SOCKET_cant_recv_more:
 
	or	[eax + SOCKET.options], SS_CANTRCVMORE
 
	ret
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_cant_send_more
;
;  IN:  eax = socket ptr
;  OUT: /
;
;-----------------------------------------------------------------
 
align 4
SOCKET_cant_send_more:
 
	or	[eax + SOCKET.options], SS_CANTSENDMORE
 
	ret

Rev 2302	Rev 2303
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	;; Written by hidnplayr@kolibrios.org, ;;	6	;; Written by hidnplayr@kolibrios.org, ;;
7	;; and Clevermouse. ;;	7	;; and Clevermouse. ;;
8	;; ;;	8	;; ;;
9	;; Based on code by mike.dld ;;	9	;; Based on code by mike.dld ;;
10	;; ;;	10	;; ;;
11	;; GNU GENERAL PUBLIC LICENSE ;;	11	;; GNU GENERAL PUBLIC LICENSE ;;
12	;; Version 2, June 1991 ;;	12	;; Version 2, June 1991 ;;
13	;; ;;	13	;; ;;
14	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	14	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
15		15
16	$Revision: 2302 $	16	$Revision: 2303 $
17		17
18		18
19	virtual at 0	19	virtual at 0
20		20
21	SOCKET:	21	SOCKET:
22	.NextPtr dd ? ; pointer to next socket in list	22	.NextPtr dd ? ; pointer to next socket in list
23	.PrevPtr dd ? ; pointer to previous socket in list	23	.PrevPtr dd ? ; pointer to previous socket in list
24	.Number dd ? ; socket number	24	.Number dd ? ; socket number
25		25
26	.lock dd ? ; lock mutex	26	.lock dd ? ; lock mutex
27		27
28	.PID dd ? ; application process id	28	.PID dd ? ; application process id
29	.Domain dd ? ; INET/UNIX/..	29	.Domain dd ? ; INET/UNIX/..
30	.Type dd ? ; RAW/STREAM/DGRAP	30	.Type dd ? ; RAW/STREAM/DGRAP
31	.Protocol dd ? ; ICMP/IPv4/ARP/TCP/UDP	31	.Protocol dd ? ; ICMP/IPv4/ARP/TCP/UDP
32	.errorcode dd ?	32	.errorcode dd ?
33		33
34	.options dd ?	34	.options dd ?
35	.state dd ?	35	.state dd ?
36	.backlog dw ? ; how many incomming connections that can be queued	36	.backlog dw ? ; how many incomming connections that can be queued
37		37
38	.snd_proc dd ?	38	.snd_proc dd ?
39	.rcv_proc dd ?	39	.rcv_proc dd ?
40		40
41	.end:	41	.end:
42	end virtual	42	end virtual
43		43
44	virtual at SOCKET.end	44	virtual at SOCKET.end
45		45
46	IP_SOCKET:	46	IP_SOCKET:
47	.LocalIP rd 4	47	.LocalIP rd 4
48	.RemoteIP rd 4	48	.RemoteIP rd 4
49		49
50	.end:	50	.end:
51	end virtual	51	end virtual
52		52
53	virtual at IP_SOCKET.end	53	virtual at IP_SOCKET.end
54		54
55	TCP_SOCKET:	55	TCP_SOCKET:
56		56
57	.LocalPort dw ?	57	.LocalPort dw ?
58	.RemotePort dw ?	58	.RemotePort dw ?
59		59
60	.t_state dd ? ; TCB state	60	.t_state dd ? ; TCB state
61	.t_rxtshift dd ?	61	.t_rxtshift dd ?
62	.t_rxtcur dd ?	62	.t_rxtcur dd ?
63	.t_dupacks dd ?	63	.t_dupacks dd ?
64	.t_maxseg dd ?	64	.t_maxseg dd ?
65	.t_force dd ?	65	.t_force dd ?
66	.t_flags dd ?	66	.t_flags dd ?
67		67
68	;---------------	68	;---------------
69	; RFC783 page 21	69	; RFC783 page 21
70		70
71	; send sequence	71	; send sequence
72	.SND_UNA dd ? ; sequence number of unack'ed sent Packets	72	.SND_UNA dd ? ; sequence number of unack'ed sent Packets
73	.SND_NXT dd ? ; next send sequence number to use	73	.SND_NXT dd ? ; next send sequence number to use
74	.SND_UP dd ?	74	.SND_UP dd ?
75	.SND_WL1 dd ? ; window minus one	75	.SND_WL1 dd ? ; window minus one
76	.SND_WL2 dd ? ;	76	.SND_WL2 dd ? ;
77	.ISS dd ? ; initial send sequence number	77	.ISS dd ? ; initial send sequence number
78	.SND_WND dd ? ; send window	78	.SND_WND dd ? ; send window
79		79
80	; receive sequence	80	; receive sequence
81	.RCV_WND dw ? ; receive window	81	.RCV_WND dw ? ; receive window
82	.RCV_NXT dd ? ; next receive sequence number to use	82	.RCV_NXT dd ? ; next receive sequence number to use
83	.RCV_UP dd ?	83	.RCV_UP dd ?
84	.IRS dd ? ; initial receive sequence number	84	.IRS dd ? ; initial receive sequence number
85		85
86	;---------------------	86	;---------------------
87	; Additional variables	87	; Additional variables
88		88
89	; receive variables	89	; receive variables
90	.RCV_ADV dd ?	90	.RCV_ADV dd ?
91		91
92	; retransmit variables	92	; retransmit variables
93	.SND_MAX dd ?	93	.SND_MAX dd ?
94		94
95	; congestion control	95	; congestion control
96	.SND_CWND dd ?	96	.SND_CWND dd ?
97	.SND_SSTHRESH dd ?	97	.SND_SSTHRESH dd ?
98		98
99	;----------------------	99	;----------------------
100	; Transmit timing stuff	100	; Transmit timing stuff
101	.t_idle dd ?	101	.t_idle dd ?
102	.t_rtt dd ?	102	.t_rtt dd ?
103	.t_rtseq dd ?	103	.t_rtseq dd ?
104	.t_srtt dd ?	104	.t_srtt dd ?
105	.t_rttvar dd ?	105	.t_rttvar dd ?
106	.t_rttmin dd ?	106	.t_rttmin dd ?
107	.max_sndwnd dd ?	107	.max_sndwnd dd ?
108		108
109	;-----------------	109	;-----------------
110	; Out-of-band data	110	; Out-of-band data
111	.t_oobflags dd ?	111	.t_oobflags dd ?
112	.t_iobc dd ?	112	.t_iobc dd ?
113	.t_softerror dd ?	113	.t_softerror dd ?
114		114
115		115
116	;---------	116	;---------
117	; RFC 1323	117	; RFC 1323
118	.SND_SCALE db ? ; Scale factor	118	.SND_SCALE db ? ; Scale factor
119	.RCV_SCALE db ?	119	.RCV_SCALE db ?
120	.request_r_scale db ?	120	.request_r_scale db ?
121	.requested_s_scale dd ?	121	.requested_s_scale dd ?
122		122
123	.ts_recent dd ?	123	.ts_recent dd ?
124	.ts_recent_age dd ?	124	.ts_recent_age dd ?
125	.last_ack_sent dd ?	125	.last_ack_sent dd ?
126		126
127		127
128	;-------	128	;-------
129	; Timers	129	; Timers
130	.timer_retransmission dw ? ; rexmt	130	.timer_retransmission dw ? ; rexmt
131	.timer_persist dw ?	131	.timer_persist dw ?
132	.timer_keepalive dw ? ; keepalive/syn timeout	132	.timer_keepalive dw ? ; keepalive/syn timeout
133	.timer_timed_wait dw ? ; also used as 2msl timer	133	.timer_timed_wait dw ? ; also used as 2msl timer
134		134
135	.end:	135	.end:
136	end virtual	136	end virtual
137		137
138	virtual at IP_SOCKET.end	138	virtual at IP_SOCKET.end
139		139
140	UDP_SOCKET:	140	UDP_SOCKET:
141		141
142	.LocalPort dw ?	142	.LocalPort dw ?
143	.RemotePort dw ?	143	.RemotePort dw ?
144	.firstpacket db ?	144	.firstpacket db ?
145		145
146	.end:	146	.end:
147	end virtual	147	end virtual
148		148
149	virtual at IP_SOCKET.end	149	virtual at IP_SOCKET.end
150		150
151	ICMP_SOCKET:	151	ICMP_SOCKET:
152		152
153	.Identifier dw ?	153	.Identifier dw ?
154		154
155	.end:	155	.end:
156	end virtual	156	end virtual
157		157
158	struc RING_BUFFER {	158	struc RING_BUFFER {
159	.start_ptr dd ? ; Pointer to start of buffer	159	.start_ptr dd ? ; Pointer to start of buffer
160	.end_ptr dd ? ; pointer to end of buffer	160	.end_ptr dd ? ; pointer to end of buffer
161	.read_ptr dd ? ; Read pointer	161	.read_ptr dd ? ; Read pointer
162	.write_ptr dd ? ; Write pointer	162	.write_ptr dd ? ; Write pointer
163	.size dd ? ; Number of bytes buffered	163	.size dd ? ; Number of bytes buffered
164	.end:	164	.end:
165	}	165	}
166		166
167	virtual at 0	167	virtual at 0
168		168
169	RING_BUFFER RING_BUFFER	169	RING_BUFFER RING_BUFFER
170		170
171	end virtual	171	end virtual
172		172
173	virtual at TCP_SOCKET.end	173	virtual at TCP_SOCKET.end
174		174
175	STREAM_SOCKET:	175	STREAM_SOCKET:
176	.rcv rd RING_BUFFER.end/4	176	.rcv rd RING_BUFFER.end/4
177	.snd rd RING_BUFFER.end/4	177	.snd rd RING_BUFFER.end/4
178	.end:	178	.end:
179		179
180	end virtual	180	end virtual
181		181
182	struct socket_queue_entry	182	struct socket_queue_entry
183	.data_ptr dd ?	183	.data_ptr dd ?
184	.buf_ptr dd ?	184	.buf_ptr dd ?
185	.data_size dd ?	185	.data_size dd ?
186	.size:	186	.size:
187	ends	187	ends
188		188
189		189
190	SOCKETBUFFSIZE equ 4096 ; in bytes	190	SOCKETBUFFSIZE equ 4096 ; in bytes
191		191
192	SOCKET_QUEUE_SIZE equ 10 ; maximum number ofincoming packets queued for 1 socket	192	SOCKET_QUEUE_SIZE equ 10 ; maximum number ofincoming packets queued for 1 socket
193	; the incoming packet queue for sockets is placed in the socket struct itself, at this location from start	193	; the incoming packet queue for sockets is placed in the socket struct itself, at this location from start
194	SOCKET_QUEUE_LOCATION equ (SOCKETBUFFSIZE - SOCKET_QUEUE_SIZE*socket_queue_entry.size - queue.data)	194	SOCKET_QUEUE_LOCATION equ (SOCKETBUFFSIZE - SOCKET_QUEUE_SIZE*socket_queue_entry.size - queue.data)
195		195
196	uglobal	196	uglobal
197	net_sockets rd 4	197	net_sockets rd 4
198	last_socket_num dd ?	198	last_socket_num dd ?
199	last_UDP_port dw ? ; These values give the number of the last used ephemeral port	199	last_UDP_port dw ? ; These values give the number of the last used ephemeral port
200	last_TCP_port dw ? ;	200	last_TCP_port dw ? ;
201	endg	201	endg
202		202
203		203
204	;-----------------------------------------------------------------	204	;-----------------------------------------------------------------
205	;	205	;
206	; SOCKET_init	206	; SOCKET_init
207	;	207	;
208	;-----------------------------------------------------------------	208	;-----------------------------------------------------------------
209	macro SOCKET_init {	209	macro SOCKET_init {
210		210
211	xor eax, eax	211	xor eax, eax
212	mov edi, net_sockets	212	mov edi, net_sockets
213	mov ecx, 5	213	mov ecx, 5
214	rep stosd	214	rep stosd
215		215
216	@@:	216	@@:
217	pseudo_random eax	217	pseudo_random eax
218	cmp ax, MIN_EPHEMERAL_PORT	218	cmp ax, MIN_EPHEMERAL_PORT
219	jb @r	219	jb @r
220	cmp ax, MAX_EPHEMERAL_PORT	220	cmp ax, MAX_EPHEMERAL_PORT
221	ja @r	221	ja @r
222	mov [last_UDP_port], ax	222	mov [last_UDP_port], ax
223		223
224	@@:	224	@@:
225	pseudo_random eax	225	pseudo_random eax
226	cmp ax, MIN_EPHEMERAL_PORT	226	cmp ax, MIN_EPHEMERAL_PORT
227	jb @r	227	jb @r
228	cmp ax, MAX_EPHEMERAL_PORT	228	cmp ax, MAX_EPHEMERAL_PORT
229	ja @r	229	ja @r
230	mov [last_TCP_port], ax	230	mov [last_TCP_port], ax
231		231
232	}	232	}
233		233
234		234
235	;-----------------------------------------------------------------	235	;-----------------------------------------------------------------
236	;	236	;
237	; Socket API (function 74)	237	; Socket API (function 74)
238	;	238	;
239	;-----------------------------------------------------------------	239	;-----------------------------------------------------------------
240	align 16	240	align 16
241	sock_sysfn_table:	241	sock_sysfn_table:
242	dd SOCKET_open ; 0	242	dd SOCKET_open ; 0
243	dd SOCKET_close ; 1	243	dd SOCKET_close ; 1
244	dd SOCKET_bind ; 2	244	dd SOCKET_bind ; 2
245	dd SOCKET_listen ; 3	245	dd SOCKET_listen ; 3
246	dd SOCKET_connect ; 4	246	dd SOCKET_connect ; 4
247	dd SOCKET_accept ; 5	247	dd SOCKET_accept ; 5
248	dd SOCKET_send ; 6	248	dd SOCKET_send ; 6
249	dd SOCKET_receive ; 7	249	dd SOCKET_receive ; 7
250	dd SOCKET_set_opt ; 8	250	dd SOCKET_set_opt ; 8
251	dd SOCKET_get_opt ; 9	251	dd SOCKET_get_opt ; 9
252		252
253	SOCKET_SYSFUNCS = ($ - sock_sysfn_table)/4	253	SOCKET_SYSFUNCS = ($ - sock_sysfn_table)/4
254		254
255		255
256	align 4	256	align 4
257	sys_socket:	257	sys_socket:
258	cmp ebx, SOCKET_SYSFUNCS-1	258	cmp ebx, SOCKET_SYSFUNCS-1
259	ja @f	259	ja @f
260	jmp dword [sock_sysfn_table + 4*ebx]	260	jmp dword [sock_sysfn_table + 4*ebx]
261	@@:	261	@@:
262	cmp ebx, 255	262	cmp ebx, 255
263	jz SOCKET_debug	263	jz SOCKET_debug
264		264
265	s_error:	265	s_error:
266	DEBUGF 1,"socket error\n"	266	DEBUGF 1,"socket error\n"
267	mov dword [esp+32], -1	267	mov dword [esp+32], -1
268		268
269	ret	269	ret
270		270
271		271
272		272
273	;-----------------------------------------------------------------	273	;-----------------------------------------------------------------
274	;	274	;
275	; SOCKET_open	275	; SOCKET_open
276	;	276	;
277	; IN: domain in ecx	277	; IN: domain in ecx
278	; type in edx	278	; type in edx
279	; protocol in esi	279	; protocol in esi
280	; OUT: eax is socket num, -1 on error	280	; OUT: eax is socket num, -1 on error
281	;	281	;
282	;-----------------------------------------------------------------	282	;-----------------------------------------------------------------
283	align 4	283	align 4
284	SOCKET_open:	284	SOCKET_open:
285		285
286	DEBUGF 1,"SOCKET_open: domain: %u, type: %u protocol: %x\n", ecx, edx, esi	286	DEBUGF 1,"SOCKET_open: domain: %u, type: %u protocol: %x\n", ecx, edx, esi
287		287
288	call SOCKET_alloc	288	call SOCKET_alloc
289	jz s_error	289	jz s_error
290		290
291	mov [esp+32], edi ; return socketnumber	291	mov [esp+32], edi ; return socketnumber
292		292
293	mov [eax + SOCKET.Domain], ecx	293	mov [eax + SOCKET.Domain], ecx
294	mov [eax + SOCKET.Type], edx	294	mov [eax + SOCKET.Type], edx
295	mov [eax + SOCKET.Protocol], esi	295	mov [eax + SOCKET.Protocol], esi
296		296
297	cmp ecx, AF_INET4	297	cmp ecx, AF_INET4
298	jne .no_inet4	298	jne .no_inet4
299		299
300	cmp edx, SOCK_DGRAM	300	cmp edx, SOCK_DGRAM
301	je .udp	301	je .udp
302		302
303	cmp edx, SOCK_STREAM	303	cmp edx, SOCK_STREAM
304	je .tcp	304	je .tcp
305		305
306	cmp edx, SOCK_RAW	306	cmp edx, SOCK_RAW
307	je .raw	307	je .raw
308		308
309	.no_inet4:	309	.no_inet4:
310	ret	310	ret
311		311
312	align 4	312	align 4
313	.raw:	313	.raw:
314	test esi, esi ; IP_PROTO_IP	314	test esi, esi ; IP_PROTO_IP
315	jz .ip	315	jz .ip
316		316
317	cmp esi, IP_PROTO_ICMP	317	cmp esi, IP_PROTO_ICMP
318	je .icmp	318	je .icmp
319		319
320	cmp esi, IP_PROTO_UDP	320	cmp esi, IP_PROTO_UDP
321	je .udp	321	je .udp
322		322
323	cmp esi, IP_PROTO_TCP	323	cmp esi, IP_PROTO_TCP
324	je .tcp	324	je .tcp
325		325
326	ret	326	ret
327		327
328	align 4	328	align 4
329	.udp:	329	.udp:
330	mov [eax + SOCKET.Protocol], IP_PROTO_UDP	330	mov [eax + SOCKET.Protocol], IP_PROTO_UDP
331	mov [eax + SOCKET.snd_proc], SOCKET_send_udp	331	mov [eax + SOCKET.snd_proc], SOCKET_send_udp
332	mov [eax + SOCKET.rcv_proc], SOCKET_receive_dgram	332	mov [eax + SOCKET.rcv_proc], SOCKET_receive_dgram
333	ret	333	ret
334		334
335	align 4	335	align 4
336	.tcp:	336	.tcp:
337	mov [eax + SOCKET.Protocol], IP_PROTO_TCP	337	mov [eax + SOCKET.Protocol], IP_PROTO_TCP
338	mov [eax + SOCKET.snd_proc], SOCKET_send_tcp	338	mov [eax + SOCKET.snd_proc], SOCKET_send_tcp
339	mov [eax + SOCKET.rcv_proc], SOCKET_receive_tcp	339	mov [eax + SOCKET.rcv_proc], SOCKET_receive_tcp
340		340
341		341
342	mov [eax + TCP_SOCKET.t_maxseg], 1480 ;;;;; FIXME	342	mov [eax + TCP_SOCKET.t_maxseg], 1480 ;;;;; FIXME
343	ret	343	ret
344		344
345		345
346	align 4	346	align 4
347	.ip:	347	.ip:
348	mov [eax + SOCKET.snd_proc], SOCKET_send_ip	348	mov [eax + SOCKET.snd_proc], SOCKET_send_ip
349	mov [eax + SOCKET.rcv_proc], SOCKET_receive_dgram	349	mov [eax + SOCKET.rcv_proc], SOCKET_receive_dgram
350	ret	350	ret
351		351
352		352
353	align 4	353	align 4
354	.icmp:	354	.icmp:
355	mov [eax + SOCKET.snd_proc], SOCKET_send_icmp	355	mov [eax + SOCKET.snd_proc], SOCKET_send_icmp
356	mov [eax + SOCKET.rcv_proc], SOCKET_receive_dgram	356	mov [eax + SOCKET.rcv_proc], SOCKET_receive_dgram
357	ret	357	ret
358		358
359		359
360		360
361	;-----------------------------------------------------------------	361	;-----------------------------------------------------------------
362	;	362	;
363	; SOCKET_bind	363	; SOCKET_bind
364	;	364	;
365	; IN: socket number in ecx	365	; IN: socket number in ecx
366	; pointer to sockaddr struct in edx	366	; pointer to sockaddr struct in edx
367	; length of that struct in esi	367	; length of that struct in esi
368	; OUT: 0 on success	368	; OUT: 0 on success
369	;	369	;
370	;-----------------------------------------------------------------	370	;-----------------------------------------------------------------
371	align 4	371	align 4
372	SOCKET_bind:	372	SOCKET_bind:
373		373
374	DEBUGF 1,"socket_bind: socknum: %u sockaddr: %x, length: %u\n", ecx, edx, esi	374	DEBUGF 1,"socket_bind: socknum: %u sockaddr: %x, length: %u\n", ecx, edx, esi
375		375
376	call SOCKET_num_to_ptr	376	call SOCKET_num_to_ptr
377	jz s_error	377	jz s_error
378		378
379	cmp esi, 2	379	cmp esi, 2
380	jb s_error	380	jb s_error
381		381
382	cmp word [edx], AF_INET4	382	cmp word [edx], AF_INET4
383	je .af_inet4	383	je .af_inet4
384		384
385	cmp word [edx], AF_UNIX	385	cmp word [edx], AF_UNIX
386	je .af_unix	386	je .af_unix
387		387
388	jmp s_error	388	jmp s_error
389		389
390	.af_unix:	390	.af_unix:
391	; TODO: write code here	391	; TODO: write code here
392		392
393	mov dword [esp+32], 0	393	mov dword [esp+32], 0
394	ret	394	ret
395		395
396	.af_inet4:	396	.af_inet4:
397		397
398	DEBUGF 1,"af_inet4\n"	398	DEBUGF 1,"af_inet4\n"
399		399
400	cmp esi, 6	400	cmp esi, 6
401	jb s_error	401	jb s_error
402		402
403	pushw [edx + 2]	403	pushw [edx + 2]
404	pop [eax + UDP_SOCKET.LocalPort]	404	pop [eax + UDP_SOCKET.LocalPort]
405		405
406	pushd [edx + 4]	406	pushd [edx + 4]
407	pop [eax + IP_SOCKET.LocalIP]	407	pop [eax + IP_SOCKET.LocalIP]
408		408
409	DEBUGF 1,"local ip: %u.%u.%u.%u\n",\	409	DEBUGF 1,"local ip: %u.%u.%u.%u\n",\
410	[eax + IP_SOCKET.LocalIP + 0]:1,[eax + IP_SOCKET.LocalIP + 1]:1,\	410	[eax + IP_SOCKET.LocalIP + 0]:1,[eax + IP_SOCKET.LocalIP + 1]:1,\
411	[eax + IP_SOCKET.LocalIP + 2]:1,[eax + IP_SOCKET.LocalIP + 3]:1	411	[eax + IP_SOCKET.LocalIP + 2]:1,[eax + IP_SOCKET.LocalIP + 3]:1
412		412
413	mov dword [esp+32], 0	413	mov dword [esp+32], 0
414	ret	414	ret
415		415
416		416
417		417
418		418
419	;-----------------------------------------------------------------	419	;-----------------------------------------------------------------
420	;	420	;
421	; SOCKET_connect	421	; SOCKET_connect
422	;	422	;
423	; IN: socket number in ecx	423	; IN: socket number in ecx
424	; pointer to sockaddr struct in edx	424	; pointer to sockaddr struct in edx
425	; length of that struct in esi	425	; length of that struct in esi
426	; OUT: 0 on success	426	; OUT: 0 on success
427	;	427	;
428	;-----------------------------------------------------------------	428	;-----------------------------------------------------------------
429	align 4	429	align 4
430	SOCKET_connect:	430	SOCKET_connect:
431		431
432	DEBUGF 1,"SOCKET_connect: socknum: %u sockaddr: %x, length: %u\n", ecx, edx, esi	432	DEBUGF 1,"SOCKET_connect: socknum: %u sockaddr: %x, length: %u\n", ecx, edx, esi
433		433
434	call SOCKET_num_to_ptr	434	call SOCKET_num_to_ptr
435	jz s_error	435	jz s_error
436		436
437	cmp esi, 8	437	cmp esi, 8
438	jb s_error	438	jb s_error
439		439
440	cmp word [edx], AF_INET4	440	cmp word [edx], AF_INET4
441	je .af_inet4	441	je .af_inet4
442		442
443	jmp s_error	443	jmp s_error
444		444
445	.af_inet4:	445	.af_inet4:
446	cmp [eax + IP_SOCKET.LocalIP], 0	446	cmp [eax + IP_SOCKET.LocalIP], 0
447	jne @f	447	jne @f
448	push [IP_LIST]	448	push [IP_LIST]
449	pop [eax + IP_SOCKET.LocalIP]	449	pop [eax + IP_SOCKET.LocalIP]
450	@@:	450	@@:
451		451
452	cmp [eax + SOCKET.Protocol], IP_PROTO_UDP	452	cmp [eax + SOCKET.Protocol], IP_PROTO_UDP
453	je .udp	453	je .udp
454		454
455	cmp [eax + SOCKET.Protocol], IP_PROTO_TCP	455	cmp [eax + SOCKET.Protocol], IP_PROTO_TCP
456	je .tcp	456	je .tcp
457		457
458	cmp [eax + SOCKET.Protocol], IP_PROTO_IP	458	cmp [eax + SOCKET.Protocol], IP_PROTO_IP
459	je .ip	459	je .ip
460		460
461	cmp [eax + SOCKET.Protocol], IP_PROTO_ICMP	461	cmp [eax + SOCKET.Protocol], IP_PROTO_ICMP
462	je .ip	462	je .ip
463		463
464	jmp s_error	464	jmp s_error
465		465
466	align 4	466	align 4
467	.udp:	467	.udp:
468	lea ebx, [eax + SOCKET.lock]	468	lea ebx, [eax + SOCKET.lock]
469	call wait_mutex	469	call wait_mutex
470		470
471	pushw [edx + 2]	471	pushw [edx + 2]
472	pop [eax + UDP_SOCKET.RemotePort]	472	pop [eax + UDP_SOCKET.RemotePort]
473		473
474	pushd [edx + 4]	474	pushd [edx + 4]
475	pop [eax + IP_SOCKET.RemoteIP]	475	pop [eax + IP_SOCKET.RemoteIP]
476		476
477	cmp [eax + UDP_SOCKET.LocalPort], 0	477	cmp [eax + UDP_SOCKET.LocalPort], 0
478	jne @f	478	jne @f
479	call SOCKET_find_port	479	call SOCKET_find_port
480	@@:	480	@@:
481		481
482	mov [eax + UDP_SOCKET.firstpacket], 0	482	mov [eax + UDP_SOCKET.firstpacket], 0
483		483
484	push eax	484	push eax
485	init_queue (eax + SOCKET_QUEUE_LOCATION) ; Set up data receiving queue	485	init_queue (eax + SOCKET_QUEUE_LOCATION) ; Set up data receiving queue
486	pop eax	486	pop eax
487		487
488	mov [eax + SOCKET.lock], 0	488	mov [eax + SOCKET.lock], 0
489	mov dword [esp+32], 0	489	mov dword [esp+32], 0
490	ret	490	ret
491		491
492	align 4	492	align 4
493	.tcp:	493	.tcp:
494	lea ebx, [eax + SOCKET.lock]	494	lea ebx, [eax + SOCKET.lock]
495	call wait_mutex	495	call wait_mutex
496		496
497	pushw [edx + 2]	497	pushw [edx + 2]
498	pop [eax + TCP_SOCKET.RemotePort]	498	pop [eax + TCP_SOCKET.RemotePort]
499		499
500	pushd [edx + 4]	500	pushd [edx + 4]

Subversion Repositories Kolibri OS

(root)/kernel/branches/net/network/socket.inc @ 2303 – Rev 2302 → 2303