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

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;                                                                 ;;
-;; Copyright (C) KolibriOS team 2004-2009. All rights reserved.    ;;
+;; Copyright (C) KolibriOS team 2004-2010. All rights reserved.    ;;
 ;; Distributed under terms of the GNU General Public License       ;;
 ;;                                                                 ;;
 ;;  SOCKET.INC                                                     ;;
 ;;                                                                 ;;
 ;;    Written by hidnplayr@kolibrios.org                           ;;
 ;;          GNU GENERAL PUBLIC LICENSE                             ;;
 ;;             Version 2, June 1991                                ;;
 ;;                                                                 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+$Revision: 1514 $
-$Revision: 1473 $
+virtual at 0
-struct	SOCKET_head
+	SOCKET:
-	 .NextPtr		dd ? ; pointer to next socket in list
+	.NextPtr		dd ? ; pointer to next socket in list
+	.PrevPtr		dd ? ; pointer to previous socket in list
+	.Number 		dd ? ; socket number
-	 .PrevPtr		dd ? ; pointer to previous socket in list
+	.lock			dd ? ; lock mutex
 	 .Number		dd ? ; socket number (unique within single process)
-	 .PID			dd ? ; application process id
+	.PID			dd ? ; application process id
-	 .Domain		dd ? ; INET/UNIX/..
+	.Domain 		dd ? ; INET/UNIX/..
-	 .Type			dd ? ; RAW/UDP/TCP/...
-	 .Protocol		dd ? ; ICMP/IPv4/ARP/
+	.Type			dd ? ; RAW/UDP/TCP/...
+	.Protocol		dd ? ; ICMP/IPv4/ARP/
+	.errorcode		dd ?
+	.options		dd ?
+	.SO_SND.SB_CC		dd ?  ;;;;; socket options: number of bytes in socket
+	.SO_RCV.SB_CC		dd ?
-	 .lock			dd ? ; lock mutex
+	.state			dd ?  ;;;;;;;;;
-	 .errorcode		dd ?
+	.end:
+end virtual
+virtual at SOCKET.end
-	 .end:
 ends
+	IP_SOCKET:
 	.LocalIP		dd ?
-struct	IPv4_SOCKET
+				rd 3 ; for IPv6 addresses
+	.RemoteIP		dd ?
+				rd 3 ; for IPv6 addresses
+	.end:
+end virtual
-	 .LocalIP		dd ?
+virtual at SOCKET.end
 	 .RemoteIP		dd ?
-	 .SequenceNumber	dd ?
+	SOCKET_virtual:
+	.ConnectedTo		dd ? ; Socket number of other socket this one is connected to
-	; todo: add options (for func 8 and 9)
+	.end:
 end virtual
 	 .end:
-ends
+virtual at IP_SOCKET.end
-struct	TCP_SOCKET
-	 .LocalPort		dw ? ; In INET byte order
-	 .RemotePort		dw ? ; In INET byte order
+	TCP_SOCKET:
-	 .backlog		dw ? ; Backlog
-	 .backlog_cur		dw ? ; current size of queue for un-accept-ed connections
-	 .last_ack_number	dd ? ; used only to let application know that ACK has been received
+	.LocalPort		dw ? ; In INET byte order
-					; todo: may be use SND_UNA instead
+	.RemotePort		dw ? ; In INET byte order
+	.backlog		dw ? ; Backlog
+	.backlog_cur		dw ? ; current size of queue for un-accept-ed connections
+	.OrigRemoteIP		dd ? ; original remote IP address (used to reset to LISTEN state)
+	.OrigRemotePort 	dw ? ; original remote port (used to reset to LISTEN state)
-					; todo: may be use events which allow additional information instead
+	.t_state		dd ? ; TCB state
+	.t_timer		dd ? ; TCB timer (seconds)
-					; todo: may be count acknowledged bytes (at least it has obvious sense)
+	.t_rxtshift		dd ?
-	 .OrigRemoteIP		dd ? ; original remote IP address (used to reset to LISTEN state)
+	.t_rxtcur		dd ?
-	 .OrigRemotePort	dw ? ; original remote port (used to reset to LISTEN state)
+	.t_dupacks		dd ?
+	.t_maxseg		dd ?
+	.t_force		dd ?
+	.t_flags		dd ?
-	 .wndsizeTimer		dd ? ; window size timer
+;---------------
+; RFC783 page 21
+; send sequence
 	.SND_UNA		dd ? ; sequence number of unack'ed sent Packets
-	; Transmission control block
+	.SND_NXT		dd ? ; next send sequence number to use
-	 .state 		dd ? ; TCB state
-	 .timer 		dd ? ; TCB timer (seconds)
+	.SND_UP 		dd ?
+	.SND_WL1		dd ? ; window minus one
+	.SND_WL2		dd ? ;
-	 .ISS			dd ? ; initial send sequence number
+	.ISS			dd ? ; initial send sequence number
-	 .IRS			dd ? ; initial receive sequence number
+	.SND_WND		dd ? ; send window
-	 .SND_UNA		dd ? ; sequence number of unack'ed sent Packets
+; 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 ?
-	 .SND_NXT		dd ? ; next send sequence number to use
+	.t_rttmin		dd ?
+	.max_sndwnd		dd ?
-	 .SND_WND		dd ? ; send window
+;-----------------
+; Out-of-band data
+	.t_oobflags		dd ?
-	 .RCV_NXT		dd ? ; next receive sequence number to use
+	.t_iobc 		dd ?
-	 .RCV_WND		dd ? ; receive window
+	.t_softerror		dd ?
-	 .SEG_LEN		dd ? ; segment length
-	 .SEG_WND		dd ? ; segment window
+;---------
+; RFC 1323
+	.SND_SCALE		db ? ; Scale factor
+	.RCV_SCALE		db ?
-	 .flags 		db ? ; packet flags
+	.request_r_scale	db ?
+	.requested_s_scale	dd ?
-	 .end:
+	.ts_recent		dd ?
-ends
+	.ts_recent_age		dd ?
 	.last_ack_sent		dd ?
-struct	UDP_SOCKET
 	.end:
+end virtual
 	 .LocalPort		dw ? ; In INET byte order
+virtual at IP_SOCKET.end
 	 .RemotePort		dw ? ; In INET byte order
-	 .firstpacket		db ?
 	UDP_SOCKET:
 	 .end:
+	.LocalPort		dw ? ; In INET byte order
-ends
+	.RemotePort		dw ? ; In INET byte order
 	.firstpacket		db ?
-struct	ICMP_SOCKET
+	.end:
+end virtual
-	.Identifier		dw ? ;
+virtual at IP_SOCKET.end
-	.end:
+	ICMP_SOCKET:
-ends
+	.Identifier		dw ? ;
+;
 ;-----------------------------------------------------------------
 align 4
 socket_init:
+	xor	eax, eax
-	mov	[net_sockets], 0
+	mov	edi, net_sockets
+	mov	ecx, 4
-	mov	[net_sockets + 4], 0
+	rep	stosd
 	mov	[last_UDP_port], MIN_EPHEMERAL_PORT
 ; Socket API (function 74)
+;
 ;-----------------------------------------------------------------
 align 4
 sys_socket:
-	and	ebx, 0x000000FF ; should i remove this line ?
-	cmp	bl , 8		; highest possible number
+	cmp	ebx, 8		; highest possible number
 	jg	s_error
 	lea	ebx, [.table + 4*ebx]
 	jmp	dword [ebx]
 .table:
-	dd	socket_open	; 0
+	dd	SOCKET_open	; 0
-	dd	socket_close	; 1
+	dd	SOCKET_close	; 1
-	dd	socket_bind	; 2
+	dd	SOCKET_bind	; 2
-	dd	socket_listen	; 3
+	dd	SOCKET_listen	; 3
-	dd	socket_connect	; 4
+	dd	SOCKET_connect	; 4
-	dd	socket_accept	; 5
+	dd	SOCKET_accept	; 5
-	dd	socket_send	; 6
+	dd	SOCKET_send	; 6
-	dd	socket_recv	; 7
+	dd	SOCKET_receive	; 7
-	dd	socket_get_opt	; 8
+	dd	SOCKET_get_opt	; 8
-;        dd      socket_set_opt  ; 9
+;        dd      SOCKET_set_opt  ; 9
 s_error:
-s_error:
+	DEBUGF	1,"socket error\n"
-	mov	dword [esp+32],-1
+	mov	dword [esp+32], -1
 	ret
 ;-----------------------------------------------------------------
 ;-----------------------------------------------------------------
 ; SOCKET_open
 ; SOCKET_open
+;
 ;  IN:  domain in ecx
 ;       type in edx
 ;       protocol in esi
 ;  OUT: eax is socket num, -1 on error
-;
 ;-----------------------------------------------------------------
-align 4
+;-----------------------------------------------------------------
-socket_open:
+align 4
+SOCKET_open:
-	DEBUGF	1,"socket_open: domain: %u, type: %u",ecx, edx
-	call	net_socket_alloc
-	or	eax, eax
-	jz	s_error
-	mov	[eax + SOCKET_head.Domain], ecx
-	mov	[eax + SOCKET_head.Type], edx
-	mov	[eax + SOCKET_head.Protocol], esi
-	cmp	ecx, AF_INET4
-	je	.af_inet4
-	jmp	.done
-  .af_inet4:
-	cmp	edx, IP_PROTO_TCP
-	je	.tcp
-	jmp	.done
-  .tcp:
-	mov	[eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.state], TCB_CLOSED
 	DEBUGF	1,"socket_open: domain: %u, type: %u protocol: %x\n", ecx, edx, esi
 ;       length of that struct in esi
 ;  OUT: 0 on success
+;
 ;-----------------------------------------------------------------
 align 4
-socket_bind:
+SOCKET_bind:
-	DEBUGF	1,"Socket_bind: socknum: %u sockaddr: %x, length: %u, ",ecx,edx,esi
+	DEBUGF	1,"socket_bind: socknum: %u sockaddr: %x, length: %u\n", ecx, edx, esi
 	stdcall net_socket_num_to_addr, ecx
-	cmp	eax, -1
+	call	SOCKET_num_to_ptr
 	jz	s_error
-	mov	dword [esp+32],0
+	mov	dword [esp+32], 0
 	ret
+  .af_inet4:
-  .af_inet4:
+	DEBUGF	1,"af_inet4\n"
 	cmp	esi, 6
 	jl	s_error
 	mov	ecx, [eax + SOCKET_head.Type]
 	mov	ecx, [eax + SOCKET.Type]
-	mov	bx, word [edx + 2]
-	DEBUGF	1,"local port: %x ",bx
+	mov	bx, word [edx + 2]
 	test	bx, bx
 	jz	.find_free
-	call	socket_check_port
-	test	bx, bx
+	call	SOCKET_check_port
-	je	s_error
+;        test    bx, bx
-	jmp	.got_port
+	jz	s_error
 	jmp	.got_port
-    .find_free:
+    .find_free:
-	call	socket_find_port
+	call	SOCKET_find_port
-	test	bx, bx
+;        test    bx, bx
-	je	s_error
+	jz	s_error
     .got_port:
-	DEBUGF	1,"using port: %x ",bx
+	DEBUGF	1,"using local port: %u", bx
-	mov	word [eax + SOCKET_head.end + IPv4_SOCKET.end + UDP_SOCKET.LocalPort], bx
+	mov	word [eax + UDP_SOCKET.LocalPort], bx
 ;-----------------------------------------------------------------
+;
 ; 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:
+SOCKET_connect:
-	DEBUGF	1,"Socket_connect: socknum: %u sockaddr: %x, length: %u,",ecx,edx,esi
 	DEBUGF	1,"socket_connect: socknum: %u sockaddr: %x, length: %u\n", ecx, edx, esi
 	stdcall net_socket_num_to_addr, ecx
-	cmp	eax, -1
+	call	SOCKET_num_to_ptr
 	jmp	s_error
   .af_inet4:
-	cmp	[eax + SOCKET_head.Type], IP_PROTO_UDP
+	cmp	[eax + SOCKET.Type], IP_PROTO_UDP
 	je	.udp
-	cmp	[eax + SOCKET_head.Type], IP_PROTO_TCP
-	je	.tcp
+	cmp	[eax + SOCKET.Type], IP_PROTO_TCP
+	je	.tcp
-	jmp	s_error
+	jmp	s_error
   .udp:
+  .udp:
 	mov	bx , word [edx + 2]
-	mov	word [eax + SOCKET_head.end + IPv4_SOCKET.end + UDP_SOCKET.RemotePort], bx
+	mov	word [eax + UDP_SOCKET.RemotePort], bx
-	mov	[eax + SOCKET_head.end + IPv4_SOCKET.end + UDP_SOCKET.firstpacket], 0
+	mov	[eax + UDP_SOCKET.firstpacket], 0
-	DEBUGF	1,"remote port: %x ",bx
+	DEBUGF	1,"remote port: %u ",bx
+	mov	ebx, dword [edx + 4]
+	mov	dword [eax + IP_SOCKET.RemoteIP], ebx
+	DEBUGF	1,"remote ip: %u.%u.%u.%u\n",[edx+4]:1,[edx+5]:1,[edx+6]:1,[edx+7]:1
-	mov	ebx, dword [edx + 4]
+	mov	dword [esp+32], 0
-	mov	dword [eax + SOCKET_head.end + IPv4_SOCKET.RemoteIP], ebx
+	ret
 	DEBUGF	1,"remote ip: %u.%u.%u.%u\n",[edx+4]:1,[edx+5]:1,[edx+6]:1,[edx+7]:1
-	mov	dword [esp+32],0
+  .tcp:
-	ret
+	; set sequence number
+	mov	ebx, [TCP_sequence_num]
-  .tcp:
+	add	[TCP_sequence_num], 6400
-	; TODO: set sequence number to random value
+	mov	[eax + TCP_SOCKET.ISS], ebx
-	lea	ebx, [eax + SOCKET_head.lock]
+	lea	ebx, [eax + SOCKET.lock]
 	call	wait_mutex
 	; fill in remote port and IP
-	mov	[eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.wndsizeTimer], 0	   ; Reset the window timer.
+;;;;;;        mov     [eax + TCP_SOCKET.wndsizeTimer], 0     ; Reset the window timer.
 											   ; TODO: figure out WTF this is
-	mov	bx , word [edx + 2]
-	mov	[eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.RemotePort], bx
-	DEBUGF	1,"remote port: %x ",bx
+	mov	bx , word [edx + 2]
-	mov	ebx, dword [edx + 4]
-	mov	[eax + SOCKET_head.end + IPv4_SOCKET.RemoteIP], ebx
-	; check if local port and IP is ok
+	mov	[eax + TCP_SOCKET.RemotePort], bx
+	DEBUGF	1,"remote port: %u ",bx
-	cmp	[eax + SOCKET_head.end + IPv4_SOCKET.LocalIP], 0
+	mov	ebx, dword [edx + 4]
-	jne	@f
-	push	[IP_LIST]	    ; device zero = default
-	pop	[eax + SOCKET_head.end + IPv4_SOCKET.LocalIP]
-       @@:
+	mov	[eax + IP_SOCKET.RemoteIP], ebx
 	cmp	[eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.LocalPort], 0
-	jne	@f
+	; check if local port and IP is ok
-	mov	ecx, [eax + SOCKET_head.Type]
+	cmp	[eax + IP_SOCKET.LocalIP], 0
-	call	socket_find_port
+	jne	@f
-	test	bx, bx
-	jz	s_error
+	push	[IP_LIST]	    ;;;;; device zero = default
 	pop	[eax + IP_SOCKET.LocalIP]
-	mov	[eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.LocalPort], bx
+       @@:
        @@:
 	cmp	[eax + TCP_SOCKET.LocalPort], 0
 	jne	@f
-	mov	[eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.state], TCB_SYN_SENT
+	call	SOCKET_find_port
-	; now say hello to the remote tcp socket
+       @@:
-	mov	bl, TH_SYN
-	xor	ecx, ecx
+;        mov     [eax + TCP_SOCKET.t_state], TCB_SYN_SENT
-	call	TCP_send
+	call	TCP_output
-	mov	dword [esp+32],0
+	mov	[eax + SOCKET.lock], 0
 	ret
+	mov	dword [esp+32], 0	; success!
+	ret
 ;-----------------------------------------------------------------
+;
 ; SOCKET_listen
 ;
+;  IN:  socket number in ecx
 ;       backlog in edx
+;  OUT: eax is socket num, -1 on error
 ;  IN:  socket number in ecx
-;       backlog in edx
+;-----------------------------------------------------------------
-;  OUT: eax is socket num, -1 on error
+align 4
 SOCKET_listen:
 ;-----------------------------------------------------------------
-align 4
-socket_listen:
+	DEBUGF	1,"Socket_listen: socknum: %u backlog: %u\n", ecx, edx
-	DEBUGF	1,"Socket_listen: socknum: %u backlog: %u\n",ecx,edx
+	call	SOCKET_num_to_ptr
 	jz	s_error
 	stdcall net_socket_num_to_addr, ecx
-	cmp	eax, -1
+	cmp	word [eax + SOCKET.Domain], AF_INET4
-	jz	s_error
+	jne	s_error
-	cmp	word [eax + SOCKET_head.Domain], AF_INET4
+	cmp	[eax + SOCKET.Type], IP_PROTO_TCP
 	jne	s_error
 	cmp	[eax + SOCKET_head.Type], IP_PROTO_TCP
-	jne	s_error
+	; TODO: check local port number
 	cmp	edx, MAX_backlog
-	jb	.ok
+	cmp	edx, MAX_backlog
-	mov	dx , MAX_backlog
+	jle	.ok
-  .ok:
+	mov	edx, MAX_backlog
   .ok:
 	mov	[eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.backlog], dx
-	mov	[eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.state], TCB_LISTEN
+	mov	[eax + TCP_SOCKET.backlog], dx
+	mov	[eax + TCP_SOCKET.t_state], TCB_LISTEN
-	mov	dword [esp+32], 0
+	 or	[eax + SOCKET.options], SO_ACCEPTCON
-	ret
+	mov	dword [esp+32], 0
 	ret
-;-----------------------------------------------------------------
-;
+;-----------------------------------------------------------------
-; SOCKET_accept
+;
-;
+; SOCKET_accept
+;
-;
+;  IN:  socket number in ecx
+;       addr in edx
-;  IN:  socket number in ecx
+;       addrlen in esi
+;  OUT: eax is socket num, -1 on error
 ;       addr in edx
-;       addrlen in esi
+;-----------------------------------------------------------------
-;  OUT: eax is socket num, -1 on error
+align 4
 SOCKET_accept:
 ;-----------------------------------------------------------------
-align 4
+	DEBUGF	1,"Socket_accept: socknum: %u sockaddr: %x, length: %u\n", ecx, edx, esi
 socket_accept:
-	DEBUGF	1,"Socket_accept: socknum: %u sockaddr: %x, length: %u\n",ecx,edx,esi
+	call	SOCKET_num_to_ptr
 	jz	s_error
 	stdcall net_socket_num_to_addr, ecx
-	or	eax, eax
+	cmp	word [eax + SOCKET.Domain], AF_INET4
-	jz	s_error
+	je	.af_inet4
-	mov	esi, eax
+	jmp	s_error
-	cmp	word [esi + SOCKET_head.Domain], AF_INET4
-	je	.af_inet4
   .af_inet4:
-	jmp	s_error
 	cmp	[eax + SOCKET.Type], IP_PROTO_TCP
-  .af_inet4:
+	je	.tcp
-	cmp	[esi + SOCKET_head.Type], IP_PROTO_TCP
+	jmp	s_error
-	je	.tcp
+  .tcp:
 	jmp	s_error
 	lea	ebx, [eax + SOCKET.lock]
-  .tcp:
-	lea	ebx, [esi + SOCKET_head.lock]
-	call	wait_mutex
-	movzx	eax, [esi + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.backlog_cur]
-	test	eax, eax
-	jz	.unlock_err
-	dec	[esi + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.backlog_cur]
-	mov	eax, [eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.end + (eax-1)*4]
-	mov	[esi + SOCKET_head.lock], 0
-	stdcall net_socket_addr_to_num, eax
-	mov	[esp+32], eax
-	ret
-  .unlock_err:
+	call	wait_mutex
-	mov	[esi + SOCKET_head.lock], 0
+	movzx	ebx, [eax + TCP_SOCKET.backlog_cur]
-	jmp	s_error
+	test	ebx, ebx
+	jz	.unlock_err
-;-----------------------------------------------------------------
-;
-; 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
 	stdcall net_socket_num_to_addr, ecx
-	or	eax, eax
-	jz	s_error
+	dec	[eax + TCP_SOCKET.backlog_cur]
-	cmp	[eax + SOCKET_head.Domain], AF_INET4
+	mov	eax, [eax + TCP_SOCKET.end + (ebx-1)*4]
-	jne	s_error
+	mov	[eax + SOCKET.lock], 0
-	cmp	[eax + SOCKET_head.Type], IP_PROTO_UDP
-	je	.udp
+	mov	dword [esp+32], 0
-	cmp	[eax + SOCKET_head.Type], IP_PROTO_ICMP
-	je	.icmp
-	cmp	[eax + SOCKET_head.Type], IP_PROTO_TCP
+	call	TCP_output	;;;;;
-	je	.tcp
 	jmp	s_error
 	ret
   .udp:
   .unlock_err:
-	stdcall net_socket_free, eax
-	mov	dword [esp+32],0
+	mov	[eax + SOCKET.lock], 0
-	ret
+	jmp	s_error
-  .icmp:
+;-----------------------------------------------------------------
+;
 ; SOCKET_close
+;
-	ret
+;  IN:  socket number in ecx
+;  OUT: eax is socket num, -1 on error
-  .tcp:
+;
-	mov	dword [esp+32],0
+;-----------------------------------------------------------------
 align 4
-	; first, remove all resend entries for this socket
+SOCKET_close:
+	DEBUGF	1,"socket_close: socknum: %u\n", ecx
-	call	TCP_remove_socket
+	call	SOCKET_num_to_ptr
-;        cmp     [eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.state], TCB_LISTEN
+	jz	s_error
 ;        je      .destroy_tcb
-;        cmp     [eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.state], TCB_SYN_SENT
+	cmp	[eax + SOCKET.Domain], AF_INET4
-;        je      .destroy_tcb
+	jne	s_error
 ;        cmp     [eac + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.state], TCB_CLOSED
-;        je      .destroy_tcb
+	cmp	[eax + SOCKET.Type], IP_PROTO_UDP
-	cmp	[eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.state], TCB_SYN_RECEIVED
+	je	.free
 	je	.fin_wait
-	cmp	[eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.state], TCB_ESTABLISHED
+	cmp	[eax + SOCKET.Type], IP_PROTO_ICMP
-	je	.fin_wait
+	je	.free
-	cmp	[eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.state], TCB_CLOSE_WAIT
-	je	.last_ack
 	cmp	[eax + SOCKET.Type], IP_PROTO_TCP
+	je	.tcp
-	stdcall net_socket_free, ebx
-	ret
+	jmp	s_error
   .tcp:
-  .last_ack:
+	test	[eax + TCP_SOCKET.t_state], TCB_SYN_RECEIVED  ;;;;;;
-	mov	[eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.state], TCB_LAST_ACK
+	jz	.free
 	jmp	.send_fin
 	call	TCP_output
   .fin_wait:
-	mov	[eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.state], TCB_FIN_WAIT_1
+	mov	dword [esp+32], 0
+	ret
+;       state must be LISTEN, SYN_SENT, CLOSED or maybe even invalid
-  .send_fin:
+;       so, we may destroy the socket
-	mov	bl, TH_FIN + TH_ACK
+  .free:
-	xor	ecx, ecx
+	call	SOCKET_free
 ;       flags in edi
 ;  OUT: -1 on error
+;
 ;-----------------------------------------------------------------
 align 4
-socket_send:
+SOCKET_send:
-	DEBUGF	1,"Socket_send: socknum: %u sockaddr: %x, length: %u, flags: %x, ",ecx,edx,esi,edi
+	DEBUGF	1,"socket_send: socknum: %u sockaddr: %x, length: %u, flags: %x\n", ecx, edx, esi, edi
 	stdcall net_socket_num_to_addr, ecx		   ; get real socket address
-	or	eax, eax
+	call	SOCKET_num_to_ptr
 	jz	s_error
-	cmp	word [eax + SOCKET_head.Domain], AF_INET4
+	cmp	word [eax + SOCKET.Domain], AF_INET4
 	je	.af_inet4
 	jmp	s_error
   .af_inet4:
-	DEBUGF	1,"Socket type:%u\n", [eax + SOCKET_head.Type]:4
-	cmp	[eax + SOCKET_head.Type], IP_PROTO_TCP
-	je	.tcp
+	DEBUGF	1,"af_inet4\n"
+	cmp	[eax + SOCKET.Type], IP_PROTO_TCP
-	cmp	[eax + SOCKET_head.Type], IP_PROTO_UDP
+	je	.tcp
-	je	.udp
-	cmp	[eax + SOCKET_head.Type], SOCK_RAW
+	cmp	[eax + SOCKET.Type], IP_PROTO_UDP
-	je	.raw
-	jmp	s_error
+	je	.udp
-  .udp:
-	DEBUGF	1,"type: UDP, "
+	jmp	s_error
-	cmp	[eax + SOCKET_head.end + IPv4_SOCKET.end + UDP_SOCKET.LocalPort],0
-	jne	@f
+  .udp:
 	DEBUGF	1,"type: UDP\n"
-	push	esi
-	mov	ecx, [eax + SOCKET_head.Type]
+; check if local port is valid
-	call	socket_find_port
+	cmp	[eax + UDP_SOCKET.LocalPort], 0
-	test	bx, bx
+	jne	@f
+	call	SOCKET_find_port
-	pop	esi
+	jz	s_error
 	je	s_error
-	mov	[eax + SOCKET_head.end + IPv4_SOCKET.end + UDP_SOCKET.LocalPort], bx
-     @@:
+; Now, send the packet
-	mov	ecx, esi
-	mov	esi, edx
+     @@:
-	call	UDP_socket_send
+	mov	ecx, esi
+	mov	esi, edx
-	and	dword [esp+32], 0
-	ret
-  .tcp:
 	call	UDP_output
 	cmp	[eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.LocalPort],0
-	jne	@f
-	push	esi
-	mov	ecx, [eax + SOCKET_head.Type]
-	call	socket_find_port
-	test	bx, bx
-	pop	esi
-	je	s_error
-	mov	[eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.LocalPort], bx
-     @@:
-	mov	ecx, esi
-	mov	esi, edx
-	mov	bl, TH_PUSH + TH_ACK
-	call	TCP_send
-	mov	[esp+32], eax
-	ret
-  .raw:
-	cmp	[eax + SOCKET_head.Protocol], IP_PROTO_IP
-	je	.raw_ip
-	cmp	[eax + SOCKET_head.Protocol], IP_PROTO_ICMP
-	je	.raw_icmp
-	jmp	s_error
-  .raw_ip:
-	;;;;;;
-	mov	[esp+32], eax
-	ret
 	mov	dword [esp+32], 0
-  .raw_icmp:
+	ret
-;        sub     ecx, ICMP_Packet.Data
+  .tcp:
-;        mov     esi, edx
-;        push    ax
+	DEBUGF	1,"type: TCP\n"
-;        call    IPv4_get_frgmnt_num
-;        mov     dx, ax
+; check if local port is valid
-;        pop     ax
+	cmp	[eax + TCP_SOCKET.LocalPort], 0
-;        shl     edx, 16
+	jne	@f
 ;        mov     dh , [esi + ICMP_Packet.Type]
-;        mov     dl , [esi + ICMP_Packet.Code]
+	call	SOCKET_find_port
-;        mov     di , [esi + ICMP_Packet.Identifier]
+	jz	s_error
 ;        mov     [eax + SOCKET.LocalPort], di            ; Set localport to the identifier number, so we can receive reply's
-;        shl     edi, 16
+     @@:
-;        mov     di , [esi + ICMP_Packet.SequenceNumber]
+;;;; TODO: queue the data
-;        add     esi, ICMP_Packet.Data
+	call	TCP_output
+	mov	[esp+32], eax
+	ret
 ;        mov     ebx, [eax + SOCKET.LocalIP]
-;        mov     eax, [eax + SOCKET.RemoteIP]
 ;        call    ICMP_create_packet
 ;-----------------------------------------------------------------
 	mov	[esp+32], eax
-	ret
+; SOCKET_get_options
+;
-;-----------------------------------------------------------------
+;  IN:  ecx = socket number
-;
+;       edx = pointer to the options:
-; SOCKET_get_options
+;               dd      level, optname, optval, optlen
-;
+;  OUT: -1 on error
 ;
-;  IN:  socket number in ecx
+; At moment, uses only pseudo-optname -2 for get last_ack_number for TCP.
-;       edx points to the options:
+; TODO: find best way to notify that send()'ed data were acknowledged
-;               dd      level, optname, optval, optlen
+; Also pseudo-optname -3 is valid and returns socket state, one of TCB_*.
-;  OUT: -1 on error
+;
-;
+;-----------------------------------------------------------------
-; At moment, uses only pseudo-optname -2 for get last_ack_number for TCP.
+align 4
-; TODO: find best way to notify that send()'ed data were acknowledged
+SOCKET_get_opt:
-; Also pseudo-optname -3 is valid and returns socket state, one of TCB_*.
-;
+	DEBUGF	1,"socket_get_opt\n"
 ;-----------------------------------------------------------------
-align 4
+	call	SOCKET_num_to_ptr
-socket_get_opt:
+	jz	s_error
 	cmp	dword [edx], IP_PROTO_TCP
-	jnz	.unknown
+	jnz	s_error
 	cmp	dword [edx+4], -2
 	jz	@f
-	cmp	dword [edx+4], -3
-	jnz	.unknown
-@@:
-	mov	eax, [edx+12]
-	test	eax, eax
+	cmp	dword [edx+4], -3
-	jz	.fail
+	jnz	s_error
-	cmp	dword [eax], 4
+@@:
-	mov	dword [eax], 4
+;        mov     eax, [edx+12]
-	jb	.fail
+;        test    eax, eax
+;        jz      .fail
+;        cmp     dword [eax], 4
-	stdcall net_socket_num_to_addr, ecx
+;        mov     dword [eax], 4
-	test	eax, eax
+;        jb      .fail
-	jz	.fail
+;        stdcall net_socket_num_to_addr, ecx
-	; todo: check that eax is really TCP socket
+;        test    eax, eax
-	mov	ecx, [eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.last_ack_number]
+;        jz      .fail
-	cmp	dword [edx+4], -2
+;        ; todo: check that eax is really TCP socket
-	jz	@f
+;        mov     ecx, [eax + TCP_SOCKET.last_ack_number]
-	mov	ecx, [eax + SOCKET_head.end + IPv4_SOCKET.end + TCP_SOCKET.state]
+;        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
+;-----------------------------------------------------------------
+;
-	mov	[eax], ecx
+; SOCKET_find_port
 @@:
+; Fills in the local port number for TCP and UDP sockets
+; This procedure always works because the number of sockets is
-	mov	dword [esp+32], 0
+; limited to a smaller number then the number of possible ports
 	ret
-.fail:
+;  IN:  eax = socket pointer
+;  OUT: /
+;
+;-----------------------------------------------------------------
+align 4
+SOCKET_find_port:
-.unknown:
-	mov	dword [esp+32], -1
+	DEBUGF	1,"socket_find_free_port\n"
-	ret
-;-----------------------------------------------------------------
-;
-; SOCKET_find_free_port (local port)
-;
-; works with INET byte order
-;
-;  IN:  type in ecx (TCP/UDP)
-;  OUT: bx = 0 on error, portnumber otherwise
-;
-;-----------------------------------------------------------------
-align 4
-socket_find_port:
 	DEBUGF	1,"Socket_find_free_port\n"
+	push	ebx esi ecx
-	cmp	ecx, IP_PROTO_UDP
-	je	.udp
+	cmp	[eax + SOCKET.Type], IP_PROTO_UDP
-	cmp	ecx, IP_PROTO_TCP
-	je	.tcp
-  .udp:
+	je	.udp
 	mov	bx, [last_UDP_port]
-	je	.continue
+	cmp	[eax + SOCKET.Type], IP_PROTO_TCP
+	je	.tcp
   .tcp:
-	mov	bx, [last_TCP_port]
+	jmp	.error
   .done:
+	mov	[eax + UDP_SOCKET.LocalPort], bx
-  .continue:
+  .error:
+	pop	ecx esi ebx
-	inc	bx
+	ret
-  .check_only:
+  .udp:
-	mov	esi, net_sockets
+	mov	bx, [last_UDP_port]
+	call	.findit
+	mov	[last_UDP_port], bx
+	jmp	.done
+  .tcp:
-  .next_socket:
+	mov	bx, [last_TCP_port]
-	mov	esi, [esi + SOCKET_head.NextPtr]
+	call	.findit
-	or	esi, esi
+	mov	[last_TCP_port], bx
-	jz	.port_ok
+	jmp	.done
-	cmp	[esi + SOCKET_head.Type], ecx
-	jne	.next_socket
+  .restart:
+	mov	bx, MIN_EPHEMERAL_PORT
-	rol	bx, 8
+  .findit:
+	inc	bx
-	cmp	[esi + SOCKET_head.end + IPv4_SOCKET.end + UDP_SOCKET.LocalPort], bx
-	rol	bx, 8				; this doesnt change the zero flag, does it ?
+	cmp	bx, MAX_EPHEMERAL_PORT
+	jz	.restart
+	call	SOCKET_check_port
-	jne	.next_socket
+	jz	.findit
-	cmp	bx, MAX_EPHEMERAL_PORT
+	ret
-	jle	.continue
 	; todo: WRAP!
-;        mov     [last_UDP_port], MIN_EPHEMERAL_PORT
+;-----------------------------------------------------------------
-  .exit:
+;
-	xor	ebx, ebx
+; SOCKET_check_port
+;
+; Checks if a local port number is unused
-  .port_ok:
+; If the proposed port number is unused, it is filled in in the socket structure
+;
-	rol	bx, 8
+;  IN:  eax = socket ptr (to find out if its a TCP/UDP socket)
-	ret
+;        bx = proposed socket number
+;
+;  OUT:  ZF = cleared on error
+;
 ;-----------------------------------------------------------------
 align 4
-; SOCKET_check_port (local port)
+SOCKET_check_port:
-;
-; works with INET byte order
+	DEBUGF	1,"socket_check_port\n"
-;
-;  IN:  type in ecx (TCP/UDP)
-;       port to check in bx
+	mov	ecx, [eax + SOCKET.Type]
+	mov	esi, net_sockets
-;  OUT: bx = 0 on error, unchanged otherwise
+  .next_socket:
+	mov	esi, [esi + SOCKET.NextPtr]
+	or	esi, esi
+	jz	.port_ok
-;-----------------------------------------------------------------
+	cmp	[esi + SOCKET.Type], 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 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
-align 4
+;       [esp] = ptr to buf
-socket_check_port:
-	mov	esi, net_sockets
+;       [esp + 4] = buf size
+;
+;  OUT: /
   .next_socket:
-	mov	esi, [esi + SOCKET_head.NextPtr]
+;-----------------------------------------------------------------
-	or	esi, esi
+align 4
-	jz	.port_ok
+SOCKET_input:
-	cmp	[esi + SOCKET_head.Type], ecx
+	DEBUGF	1,"socket_input: socket=%x, data=%x size=%u\n", eax, esi, ecx
 	jne	.next_socket
 	mov	dword[esp+4], ecx
-	cmp	[esi + SOCKET_head.end + IPv4_SOCKET.end + UDP_SOCKET.LocalPort], bx
+	push	esi
+	mov	esi, esp
+	add_to_queue (eax + SOCKET_QUEUE_LOCATION),\
-	jne	.next_socket
+		     SOCKET_QUEUE_SIZE,\
 		     socket_queue_entry.size,\
-	xor	ebx, ebx
+		     SOCKET_input.full
-  .port_ok:
+	DEBUGF	1,"Queued packet successfully\n"
-	ret
+	add	esp, socket_queue_entry.size
-;-----------------------------------------------------------------
-;
-; SOCKET_internal_receiver
+	mov	[eax + SOCKET.lock], 0
+	jmp	SOCKET_notify_owner
+  .full:
+	DEBUGF	2,"Socket %x is full!\n", eax
+	mov	[eax + SOCKET.lock], 0
+	call	kernel_free
+	add	esp, 8
 	ret
 ; Updates a socket with received data
 ;-----------------------------------------------------------------
 ; Note: the mutex must already be set !
+; SOCKET_notify_owner
 ;
+; notify's the owner of a socket that something happened
+;
 ;  IN:  eax = socket ptr
-;       ecx = size
+;  OUT: /
+;
+;-----------------------------------------------------------------
+align 4
+SOCKET_notify_owner:
-;       esi = pointer to buffer
+	DEBUGF	1,"socket_notify_owner\n"
-;       edi = offset
-;
-;  OUT: xxx
+	call	SOCKET_check
 	jz	.error
 ;-----------------------------------------------------------------
-align 4
+	push	ecx eax esi
 socket_internal_receiver:
-	DEBUGF	1,"Internal socket receiver: buffer %x, offset: %x size=%u socket: %x\n", esi, edi, ecx, eax
+; socket exists, now try to flag an event to the application
 	push	edi	; offset
-	push	ecx	; size
+	mov	eax, [eax + SOCKET.PID]
-	push	esi	; data_ptr
+	mov	ecx, 1
-	mov	esi, esp
+	mov	esi, TASK_DATA + TASKDATA.pid
-	add_to_queue (eax + SOCKET_QUEUE_LOCATION), SOCKET_QUEUE_SIZE, socket_queue_entry.size, notify_network_event.full
-	DEBUGF	1,"Queued packet successfully\n"
-	add	esp, socket_queue_entry.size
-	mov	[eax + SOCKET_head.lock], 0
-notify_network_event:
-	; flag an event to the application
-	mov	edx, [eax + SOCKET_head.PID]				; get socket owner PID
-	mov	ecx, 1
-	mov	esi, TASK_DATA + TASKDATA.pid
-       .next_pid:
-	cmp	[esi], edx
-	je	.found_pid
-	inc	ecx
 	add	esi, 0x20
-	cmp	ecx, [TASK_COUNT]
+       .next_pid:
-	jbe	.next_pid
+	cmp	[esi], eax
-	ret
+	je	.found_pid
 	inc	ecx
-       .found_pid:
+	add	esi, 0x20
-	shl	ecx, 8
+	cmp	ecx, [TASK_COUNT]
-	or	[ecx + SLOT_BASE + APPDATA.event_mask], EVENT_NETWORK	; stack event
+	jbe	.next_pid
 	mov	[check_idle_semaphore], 200
-	ret
+; PID not found, TODO: close socket!
-  .full:
+	jmp	.error2
-	DEBUGF	2,"Socket %x is full!\n",eax
-	mov	[eax + SOCKET_head.lock], 0
 	call	kernel_free
-	add	esp, 8
+       .found_pid:
-	ret
+	shl	ecx, 8
+	or	[ecx + SLOT_BASE + APPDATA.event_mask], EVENT_NETWORK
+	mov	[check_idle_semaphore], 200
+	DEBUGF	1,"owner notified\n"
+  .error2:
+	pop	esi eax ecx
+  .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: %x ", eax
-; Allocate memory for socket data and put new socket into the list
+	or	eax, eax
-; Newly created socket is initialized with calling PID and number and
+	jz	.exit
 ; put into beginning of list (which is a fastest way).
-;
+; zero-initialize allocated memory
-; @return socket structure address in EAX
+	push	eax edi
-;
+	mov	edi, eax
+	mov	ecx, SOCKETBUFFSIZE / 4
-proc net_socket_alloc stdcall uses ebx ecx edx edi
+	xor	eax, eax
-	stdcall kernel_alloc, SOCKETBUFFSIZE
+	rep	stosd
+	pop	edi eax
-	DEBUGF	1, "K : net_socket_alloc (0x%x)\n", eax
-	; check if we can allocate needed amount of memory
+	init_queue (eax + SOCKET_QUEUE_LOCATION)
-	or	eax, eax
-	jz	.exit
-	; zero-initialize allocated memory
-	push	eax
+; find first free socket number and use it
-	mov	edi, eax
-	mov	ecx, SOCKETBUFFSIZE / 4
+	mov	ebx, net_sockets
-;        cld
+	xor	ecx, ecx
-	xor	eax, eax
-	rep	stosd
-	pop	eax
+  .next_socket_number:
+	inc	ecx
+  .next_socket:
+	mov	ebx, [ebx + SOCKET.NextPtr]
-	init_queue (eax + SOCKET_QUEUE_LOCATION)
+	or	ebx, ebx
+	jz	.last_socket
+	cmp	[ebx + SOCKET.Number], ecx
-	; add socket to the list by changing pointers
+	jne	.next_socket
 	mov	ebx, net_sockets
+	jmp	.next_socket_number
-	push	[ebx + SOCKET_head.NextPtr]
+  .last_socket:
-	mov	[ebx + SOCKET_head.NextPtr], eax
+	mov	[eax + SOCKET.Number], ecx
 	mov	[eax + SOCKET_head.PrevPtr], ebx
-	pop	ebx
+	DEBUGF	1, "(number: %u)\n", ecx
+; Fill in PID
+	mov	ebx, [TASK_BASE]
-	mov	[eax + SOCKET_head.NextPtr], ebx
+	mov	ebx, [ebx + TASKDATA.pid]
-	or	ebx, ebx
-	jz	@f
-	mov	[ebx + SOCKET_head.PrevPtr], eax
+	mov	[eax + SOCKET.PID], ebx
+; add socket to the list by changing pointers
-    @@: ; set socket owner PID to the one of calling process
+	mov	ebx, [net_sockets + SOCKET.NextPtr]
-	mov	ebx, [TASK_BASE]
 	mov	ebx, [ebx + TASKDATA.pid]
-	mov	[eax + SOCKET_head.PID], ebx
+	mov	[eax + SOCKET.PrevPtr], net_sockets
+	mov	[eax + SOCKET.NextPtr], ebx
+	or	ebx, ebx
+	jz	@f
 	add	ebx, SOCKET.lock	; lock the next socket
-	; find first free socket number and use it
-	;mov     edx, ebx
-	mov	ebx, net_sockets
-	xor	ecx, ecx
+	call	wait_mutex
-  .next_socket_number:
+	sub	ebx, SOCKET.lock
-	inc	ecx
+	mov	[ebx + SOCKET.PrevPtr], eax
+	mov	[ebx + SOCKET.lock], 0
-  .next_socket:
+       @@:
-	mov	ebx, [ebx + SOCKET_head.NextPtr]
+	mov	[net_sockets + SOCKET.NextPtr], eax
-	or	ebx, ebx
+	mov	edi, ecx
-	jz	.last_socket_number
+	or	eax, eax	; used to clear zero flag
+  .exit:
-	cmp	[ebx + SOCKET_head.Number], ecx
+	pop	ebx ecx
-	jne	.next_socket
-	;cmp     [ebx + SOCKET.PID], edx
-	;jne     .next_socket
-	mov	ebx, net_sockets
-	jmp	.next_socket_number
-  .last_socket_number:
+	ret
-	mov	[eax + SOCKET_head.Number], ecx
-  .exit:
+;----------------------------------------------------
 	ret
-endp
-; Free socket data memory and pop socket off the list
-;
+; SOCKET_free
-; @param sockAddr is a socket structure address
+;
 ; Free socket data memory and remove socket from the list
-proc net_socket_free stdcall uses ebx ecx edx, sockAddr:DWORD
 	mov	eax, [sockAddr]
-	DEBUGF	1, "K : net_socket_free (0x%x)\n", eax
+; IN:  eax = socket ptr
-	; check if we got something similar to socket structure address
+; OUT: /
-	or	eax, eax
-	jz	.error
+;
+;----------------------------------------------------
-	; make sure sockAddr is one of the socket addresses in the list
+align 4
-	mov	ebx, net_sockets
+SOCKET_free:
+	DEBUGF	1, "socket_free: %x\n", eax
-	;mov     ecx, [TASK_BASE]
+	call	SOCKET_check
-	;mov     ecx, [ecx + TASKDATA.pid]
+	jz	.error
-  .next_socket:
+	push	ebx
-	mov	ebx, [ebx + SOCKET_head.NextPtr]
+	lea	ebx, [eax + SOCKET.lock]
+	call	wait_mutex
-	or	ebx, ebx
+	DEBUGF	1, "freeing socket..\n"
-	jz	.error
-	cmp	ebx, eax
+	push	eax				; this will be passed to kernel_free
+	mov	ebx, [eax + SOCKET.NextPtr]
+	mov	eax, [eax + SOCKET.PrevPtr]
+	DEBUGF	1, "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
+       @@:
-	jne	.next_socket
+	call	kernel_free
+	pop	ebx
+	DEBUGF	1, "socket is gone!\n"
+  .error:
+	ret
+;---------------------------------------------------
 	;cmp     [ebx + SOCKET.PID], ecx
-	;jne     .next_socket
+; SOCKET_num_to_ptr
 	; okay, we found the correct one
-	; remove it from the list first, changing pointers
+; Get socket structure address by its number
 	mov	ebx, [eax + SOCKET_head.NextPtr]
-	mov	eax, [eax + SOCKET_head.PrevPtr]
+; IN:  ecx = socket number
-	mov	[eax + SOCKET_head.NextPtr], ebx
+; OUT: ecx = 0 on error, socket ptr otherwise
-	or	ebx, ebx
+;       ZF = set on error
+;
+;---------------------------------------------------
-	jz	@f
+align 4
-	mov	[ebx + SOCKET_head.PrevPtr], eax
+SOCKET_num_to_ptr:
-	lea	ebx, [eax + SOCKET_head.lock]
-	call	wait_mutex
+	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\n"
+	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:
-    @@: ; and finally free the memory structure used
+	mov	eax, ebx
+	test	eax, eax
+	pop	ebx
+	ret
+;---------------------------------------------------
+;
+; SOCKET_check_owner
+;
-	stdcall kernel_free, [sockAddr]
+; checks if the caller application owns the socket
-	ret

Subversion Repositories Kolibri OS

(root)/kernel/branches/net/network/socket.inc – Rev 1473 → 1514