1860 lines
44 KiB
PHP
1860 lines
44 KiB
PHP
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ;;
|
|
;; Copyright (C) KolibriOS team 2004-2012. 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$
|
|
|
|
|
|
struct SOCKET
|
|
|
|
NextPtr dd ? ; pointer to next socket in list
|
|
PrevPtr dd ? ; pointer to previous socket in list
|
|
Number dd ? ; socket number
|
|
|
|
mutex 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 ?
|
|
|
|
ends
|
|
|
|
struct IP_SOCKET SOCKET
|
|
|
|
LocalIP rd 4
|
|
RemoteIP rd 4
|
|
|
|
ends
|
|
|
|
struct TCP_SOCKET IP_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 ; the order of next 4 elements may not change
|
|
|
|
SND_SCALE db ?
|
|
RCV_SCALE db ?
|
|
requested_s_scale db ?
|
|
request_r_scale db ?
|
|
|
|
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
|
|
|
|
ends
|
|
|
|
struct UDP_SOCKET IP_SOCKET
|
|
|
|
LocalPort dw ?
|
|
RemotePort dw ?
|
|
firstpacket db ?
|
|
|
|
ends
|
|
|
|
|
|
struct ICMP_SOCKET IP_SOCKET
|
|
|
|
Identifier dw ?
|
|
|
|
ends
|
|
|
|
|
|
struct 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
|
|
|
|
ends
|
|
|
|
struct STREAM_SOCKET TCP_SOCKET
|
|
|
|
rcv RING_BUFFER
|
|
snd RING_BUFFER
|
|
|
|
ends
|
|
|
|
struct socket_queue_entry
|
|
|
|
data_ptr dd ?
|
|
buf_ptr dd ?
|
|
data_size dd ?
|
|
|
|
ends
|
|
|
|
|
|
SOCKETBUFFSIZE = 4096 ; in bytes
|
|
|
|
SOCKET_QUEUE_SIZE = 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 = (SOCKETBUFFSIZE - SOCKET_QUEUE_SIZE*sizeof.socket_queue_entry - sizeof.queue)
|
|
|
|
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 4
|
|
sys_socket:
|
|
|
|
cmp ebx, 255
|
|
jz SOCKET_debug
|
|
|
|
cmp ebx, .number
|
|
ja s_error
|
|
jmp dword [.table + 4*ebx]
|
|
|
|
.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
|
|
.number = ($ - .table) / 4 - 1
|
|
|
|
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
|
|
|
|
push ecx edx esi
|
|
call SOCKET_alloc
|
|
pop esi edx ecx
|
|
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
|
|
|
|
TCP_init_socket eax
|
|
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
|
|
|
|
cmp [eax + SOCKET.Protocol], IP_PROTO_UDP
|
|
je .udp
|
|
|
|
cmp [eax + SOCKET.Protocol], IP_PROTO_TCP
|
|
je .tcp
|
|
|
|
jmp s_error
|
|
|
|
.tcp:
|
|
.udp:
|
|
|
|
mov ebx, [edx + 4] ; First, fill in the IP
|
|
test ebx, ebx ; If IP is 0, use default
|
|
jnz @f
|
|
mov ebx, [NET_DEFAULT]
|
|
mov ebx, [IP_LIST + 4*ebx]
|
|
@@:
|
|
mov [eax + IP_SOCKET.LocalIP], ebx
|
|
|
|
mov bx, [edx + 2] ; Now fill in the port if it's still available
|
|
call SOCKET_check_port
|
|
jz s_error ; ZF is set by socket_check_port, on error
|
|
|
|
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:
|
|
pusha
|
|
lea ecx, [eax + SOCKET.mutex]
|
|
call mutex_lock
|
|
popa
|
|
|
|
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
|
|
|
|
lea ecx, [eax + SOCKET.mutex]
|
|
call mutex_unlock
|
|
|
|
mov dword [esp+32], 0
|
|
ret
|
|
|
|
align 4
|
|
.tcp:
|
|
pusha
|
|
lea ecx, [eax + SOCKET.mutex]
|
|
call mutex_lock
|
|
popa
|
|
|
|
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
|
|
|
|
pusha
|
|
lea ecx, [eax + SOCKET.mutex]
|
|
call mutex_unlock
|
|
popa
|
|
|
|
mov eax, ebx
|
|
call TCP_output
|
|
|
|
mov dword [esp+32], 0
|
|
ret
|
|
|
|
align 4
|
|
.ip:
|
|
pusha
|
|
lea ecx, [eax + SOCKET.mutex]
|
|
call mutex_lock
|
|
popa
|
|
|
|
pushd [edx + 4]
|
|
pop [eax + IP_SOCKET.RemoteIP]
|
|
|
|
push eax
|
|
init_queue (eax + SOCKET_QUEUE_LOCATION) ; Set up data receiving queue
|
|
pop eax
|
|
|
|
lea ecx, [eax + SOCKET.mutex]
|
|
call mutex_unlock
|
|
|
|
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]
|
|
|
|
; Change PID to that of the current process
|
|
mov ebx, [TASK_BASE]
|
|
mov ebx, [ebx + TASKDATA.pid]
|
|
mov [eax + SOCKET.PID], ebx
|
|
|
|
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_drop
|
|
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, sizeof.socket_queue_entry, 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"
|
|
|
|
mov [esp+32], ecx
|
|
call UDP_output
|
|
cmp eax, -1
|
|
je s_error
|
|
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
|
|
|
|
mov [esp+32], ecx
|
|
|
|
call TCP_output
|
|
ret
|
|
|
|
|
|
align 4
|
|
SOCKET_send_ip:
|
|
|
|
DEBUGF 1,"type: IP\n"
|
|
|
|
mov [esp+32], ecx
|
|
call IPv4_output_raw
|
|
cmp eax, -1
|
|
je s_error
|
|
ret
|
|
|
|
|
|
align 4
|
|
SOCKET_send_icmp:
|
|
|
|
DEBUGF 1,"SOCKET_send: ICMP\n"
|
|
|
|
mov [esp+32], ecx
|
|
call ICMP_output_raw
|
|
cmp eax, -1
|
|
je s_error
|
|
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 edx, [eax + IP_SOCKET.LocalIP]
|
|
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 + IP_SOCKET.LocalIP], edx
|
|
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, sizeof.socket_queue_entry, SOCKET_input.full
|
|
|
|
DEBUGF 1,"SOCKET_input: queued packet successfully\n"
|
|
add esp, sizeof.socket_queue_entry
|
|
|
|
pusha
|
|
lea ecx, [eax + SOCKET.mutex]
|
|
call mutex_unlock
|
|
popa
|
|
|
|
jmp SOCKET_notify_owner
|
|
|
|
.full:
|
|
DEBUGF 2,"SOCKET_input: socket %x is full!\n", eax
|
|
|
|
pusha
|
|
lea ecx, [eax + SOCKET.mutex]
|
|
call mutex_unlock
|
|
popa
|
|
|
|
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
|
|
jc .way_too_large
|
|
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: ; update size, we will fill buffer completely
|
|
sub [eax + RING_BUFFER.size], SOCKET_MAXDATA
|
|
sub ecx, [eax + RING_BUFFER.size]
|
|
mov [eax + RING_BUFFER.size], SOCKET_MAXDATA
|
|
ja .copy
|
|
|
|
.full:
|
|
DEBUGF 2,"SOCKET_ring_write: ring buffer is full!\n"
|
|
xor ecx, ecx
|
|
ret
|
|
|
|
.way_too_large:
|
|
sub [eax + RING_BUFFER.size], ecx
|
|
mov ecx, SOCKET_MAXDATA
|
|
sub ecx, [eax + RING_BUFFER.size]
|
|
ja .copy
|
|
jmp .full
|
|
|
|
|
|
|
|
;-----------------------------------------------------------------
|
|
;
|
|
; 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 ebx
|
|
|
|
stdcall kernel_alloc, SOCKETBUFFSIZE
|
|
DEBUGF 1, "SOCKET_alloc: ptr=%x\n", eax
|
|
or eax, eax
|
|
jz .exit
|
|
|
|
; zero-initialize allocated memory
|
|
push eax
|
|
mov edi, eax
|
|
mov ecx, SOCKETBUFFSIZE / 4
|
|
xor eax, eax
|
|
rep stosd
|
|
pop 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 edi, [last_socket_num]
|
|
.next_socket_number:
|
|
inc edi
|
|
jz .next_socket_number ; avoid socket nr 0
|
|
cmp edi, -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], edi
|
|
jne .next_socket
|
|
jmp .next_socket_number
|
|
|
|
.last_socket:
|
|
mov [last_socket_num], edi
|
|
mov [eax + SOCKET.Number], edi
|
|
DEBUGF 1, "SOCKET_alloc: number=%u\n", edi
|
|
|
|
; Fill in PID
|
|
mov ebx, [TASK_BASE]
|
|
mov ebx, [ebx + TASKDATA.pid]
|
|
mov [eax + SOCKET.PID], ebx
|
|
|
|
; init mutex
|
|
pusha
|
|
lea ecx, [eax + SOCKET.mutex]
|
|
call mutex_init
|
|
popa
|
|
|
|
; 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
|
|
|
|
pusha
|
|
lea ecx, [ebx + SOCKET.mutex]
|
|
call mutex_lock
|
|
popa
|
|
|
|
mov [ebx + SOCKET.PrevPtr], eax
|
|
|
|
pusha
|
|
lea ecx, [ebx + SOCKET.mutex]
|
|
call mutex_unlock
|
|
popa
|
|
@@:
|
|
|
|
mov [net_sockets + SOCKET.NextPtr], eax
|
|
or eax, eax ; used to clear zero flag
|
|
.exit:
|
|
pop ebx
|
|
|
|
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
|
|
|
|
pusha
|
|
lea ecx, [eax + SOCKET.mutex]
|
|
call mutex_lock
|
|
popa
|
|
|
|
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.start_ptr]
|
|
stdcall kernel_free, [ebx + STREAM_SOCKET.snd.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
|
|
push ebx
|
|
call SOCKET_alloc
|
|
pop ebx
|
|
jz .fail
|
|
|
|
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
|
|
|
|
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 |