forked from KolibriOS/kolibrios
412 lines
14 KiB
PHP
412 lines
14 KiB
PHP
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ;;
|
|
;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;
|
|
;; Distributed under terms of the GNU General Public License ;;
|
|
;; ;;
|
|
;; UDP.INC ;;
|
|
;; ;;
|
|
;; Part of the tcp/ip network stack for KolibriOS ;;
|
|
;; ;;
|
|
;; Written by hidnplayr@kolibrios.org ;;
|
|
;; ;;
|
|
;; GNU GENERAL PUBLIC LICENSE ;;
|
|
;; Version 2, June 1991 ;;
|
|
;; ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
$Revision$
|
|
|
|
|
|
struct UDP_header
|
|
|
|
SourcePort dw ?
|
|
DestinationPort dw ?
|
|
Length dw ? ; Length of (UDP Header + Data)
|
|
Checksum dw ?
|
|
|
|
ends
|
|
|
|
|
|
uglobal
|
|
align 4
|
|
|
|
UDP_PACKETS_TX rd NET_DEVICES_MAX
|
|
UDP_PACKETS_RX rd NET_DEVICES_MAX
|
|
|
|
endg
|
|
|
|
|
|
;-----------------------------------------------------------------;
|
|
; ;
|
|
; UDP_init: This function resets all UDP variables ;
|
|
; ;
|
|
;-----------------------------------------------------------------;
|
|
macro UDP_init {
|
|
|
|
xor eax, eax
|
|
mov edi, UDP_PACKETS_TX
|
|
mov ecx, 2*NET_DEVICES_MAX
|
|
rep stosd
|
|
}
|
|
|
|
|
|
macro UDP_checksum IP1, IP2 { ; esi = ptr to udp packet, ecx = packet size, destroys: ecx, edx
|
|
|
|
; Pseudoheader
|
|
mov edx, IP_PROTO_UDP
|
|
|
|
add dl, byte[IP1+1]
|
|
adc dh, byte[IP1+0]
|
|
adc dl, byte[IP1+3]
|
|
adc dh, byte[IP1+2]
|
|
|
|
adc dl, byte[IP2+1]
|
|
adc dh, byte[IP2+0]
|
|
adc dl, byte[IP2+3]
|
|
adc dh, byte[IP2+2]
|
|
|
|
adc dl, cl ; byte[esi+UDP_header.Length+1]
|
|
adc dh, ch ; byte[esi+UDP_header.Length+0]
|
|
|
|
; Done with pseudoheader, now do real header
|
|
adc dl, byte[esi+UDP_header.SourcePort+1]
|
|
adc dh, byte[esi+UDP_header.SourcePort+0]
|
|
|
|
adc dl, byte[esi+UDP_header.DestinationPort+1]
|
|
adc dh, byte[esi+UDP_header.DestinationPort+0]
|
|
|
|
adc dl, byte[esi+UDP_header.Length+1]
|
|
adc dh, byte[esi+UDP_header.Length+0]
|
|
|
|
adc edx, 0
|
|
|
|
; Done with header, now do data
|
|
push esi
|
|
movzx ecx, [esi+UDP_header.Length]
|
|
rol cx , 8
|
|
sub cx , sizeof.UDP_header
|
|
add esi, sizeof.UDP_header
|
|
|
|
call checksum_1
|
|
call checksum_2
|
|
pop esi
|
|
|
|
add [esi+UDP_header.Checksum], dx ; this final instruction will set or clear ZF :)
|
|
|
|
}
|
|
|
|
|
|
;-----------------------------------------------------------------;
|
|
; ;
|
|
; UDP_input: Inject the UDP data in the application sockets. ;
|
|
; ;
|
|
; IN: [esp] = ptr to buffer ;
|
|
; ebx = ptr to device struct ;
|
|
; ecx = UDP packet size ;
|
|
; edx = ptr to IPv4 header ;
|
|
; esi = ptr to UDP packet data ;
|
|
; edi = interface number*4 ;
|
|
; ;
|
|
; OUT: / ;
|
|
; ;
|
|
;-----------------------------------------------------------------;
|
|
align 4
|
|
UDP_input:
|
|
|
|
DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_input: size=%u\n", ecx
|
|
|
|
; First validate, checksum
|
|
|
|
neg [esi + UDP_header.Checksum] ; substract checksum from 0
|
|
jz .no_checksum ; if checksum is zero, it is considered valid
|
|
|
|
; otherwise, we will re-calculate the checksum and add it to this value, thus creating 0 when it is correct
|
|
|
|
mov eax, edx
|
|
UDP_checksum (eax+IPv4_header.SourceAddress), (eax+IPv4_header.DestinationAddress)
|
|
jnz .checksum_mismatch
|
|
|
|
.no_checksum:
|
|
DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_input: checksum ok\n"
|
|
|
|
; Convert length to little endian
|
|
|
|
rol [esi + UDP_header.Length], 8
|
|
|
|
; Look for a socket where
|
|
; IP Packet UDP Destination Port = local Port
|
|
; IP Packet SA = Remote IP
|
|
|
|
pusha
|
|
mov ecx, socket_mutex
|
|
call mutex_lock
|
|
popa
|
|
|
|
mov cx, [esi + UDP_header.SourcePort]
|
|
mov dx, [esi + UDP_header.DestinationPort]
|
|
mov eax, net_sockets
|
|
.next_socket:
|
|
mov eax, [eax + SOCKET.NextPtr]
|
|
or eax, eax
|
|
jz .unlock_dump
|
|
|
|
cmp [eax + SOCKET.Domain], AF_INET4
|
|
jne .next_socket
|
|
|
|
cmp [eax + SOCKET.Protocol], IP_PROTO_UDP
|
|
jne .next_socket
|
|
|
|
cmp [eax + UDP_SOCKET.LocalPort], dx
|
|
jne .next_socket
|
|
|
|
DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_input: socket=%x\n", eax
|
|
|
|
pusha
|
|
mov ecx, socket_mutex
|
|
call mutex_unlock
|
|
popa
|
|
|
|
;;; TODO: when packet is processed, check more sockets?!
|
|
|
|
; FIXME: check remote IP if possible
|
|
;
|
|
; cmp [eax + IP_SOCKET.RemoteIP], 0xffffffff
|
|
; je @f
|
|
; cmp [eax + IP_SOCKET.RemoteIP],
|
|
; jne .next_socket
|
|
; @@:
|
|
|
|
cmp [eax + UDP_SOCKET.RemotePort], 0
|
|
je .updateport
|
|
|
|
cmp [eax + UDP_SOCKET.RemotePort], cx
|
|
jne .dump
|
|
|
|
pusha
|
|
lea ecx, [eax + SOCKET.mutex]
|
|
call mutex_lock
|
|
popa
|
|
|
|
.updatesock:
|
|
inc [UDP_PACKETS_RX + edi]
|
|
|
|
movzx ecx, [esi + UDP_header.Length]
|
|
sub ecx, sizeof.UDP_header
|
|
add esi, sizeof.UDP_header
|
|
|
|
jmp SOCKET_input
|
|
|
|
.updateport:
|
|
pusha
|
|
lea ecx, [eax + SOCKET.mutex]
|
|
call mutex_lock
|
|
popa
|
|
|
|
DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_input: new remote port=%x\n", cx ; FIXME: find a way to print big endian values with debugf
|
|
mov [eax + UDP_SOCKET.RemotePort], cx
|
|
jmp .updatesock
|
|
|
|
.unlock_dump:
|
|
pusha
|
|
mov ecx, socket_mutex
|
|
call mutex_unlock
|
|
popa
|
|
|
|
DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_input: no socket found\n"
|
|
jmp .dump
|
|
|
|
.checksum_mismatch:
|
|
DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_input: checksum mismatch\n"
|
|
|
|
.dump:
|
|
DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_input: dumping\n"
|
|
call NET_BUFF_free
|
|
ret
|
|
|
|
|
|
|
|
;-----------------------------------------------------------------;
|
|
; ;
|
|
; UDP_output: Create an UDP packet. ;
|
|
; ;
|
|
; IN: eax = socket pointer ;
|
|
; ecx = number of bytes to send ;
|
|
; esi = pointer to data ;
|
|
; ;
|
|
; OUT: eax = -1 on error ;
|
|
; ;
|
|
;-----------------------------------------------------------------;
|
|
|
|
align 4
|
|
UDP_output:
|
|
|
|
DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_output: socket=%x bytes=%u data_ptr=%x\n", eax, ecx, esi
|
|
|
|
mov dx, [eax + UDP_SOCKET.RemotePort]
|
|
DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_output: remote port=%x, ", dx ; FIXME: find a way to print big endian values with debugf
|
|
rol edx, 16
|
|
mov dx, [eax + UDP_SOCKET.LocalPort]
|
|
DEBUGF DEBUG_NETWORK_VERBOSE, "local port=%x\n", dx
|
|
|
|
sub esp, 4 ; Data ptr will be placed here
|
|
push edx esi
|
|
mov ebx, [eax + IP_SOCKET.device]
|
|
mov edx, [eax + IP_SOCKET.LocalIP]
|
|
mov edi, [eax + IP_SOCKET.RemoteIP]
|
|
mov al, [eax + IP_SOCKET.ttl]
|
|
mov ah, IP_PROTO_UDP
|
|
add ecx, sizeof.UDP_header
|
|
call IPv4_output
|
|
jz .fail
|
|
mov [esp + 8], eax ; pointer to buffer start
|
|
|
|
mov [edi + UDP_header.Length], cx
|
|
rol [edi + UDP_header.Length], 8
|
|
|
|
pop esi
|
|
push edi ecx
|
|
sub ecx, sizeof.UDP_header
|
|
add edi, sizeof.UDP_header
|
|
shr ecx, 2
|
|
rep movsd
|
|
mov ecx, [esp]
|
|
and ecx, 3
|
|
rep movsb
|
|
pop ecx edi
|
|
|
|
pop dword [edi + UDP_header.SourcePort]
|
|
|
|
; Checksum
|
|
mov esi, edi
|
|
mov [edi + UDP_header.Checksum], 0
|
|
UDP_checksum (edi-4), (edi-8) ; FIXME: IPv4 packet could have options..
|
|
|
|
DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_output: sending with device %x\n", ebx
|
|
call [ebx + NET_DEVICE.transmit]
|
|
test eax, eax
|
|
jnz @f
|
|
call NET_ptr_to_num4
|
|
inc [UDP_PACKETS_TX + edi]
|
|
@@:
|
|
|
|
ret
|
|
|
|
.fail:
|
|
DEBUGF DEBUG_NETWORK_ERROR, "UDP_output: failed\n"
|
|
add esp, 4+4+8
|
|
or eax, -1
|
|
ret
|
|
|
|
|
|
|
|
|
|
;-----------------------------------------------------------------;
|
|
; ;
|
|
; UDP_connect ;
|
|
; ;
|
|
; IN: eax = socket pointer ;
|
|
; ;
|
|
; OUT: eax = 0 on success ;
|
|
; eax = -1 on error ;
|
|
; ebx = error code on error ;
|
|
; ;
|
|
;-----------------------------------------------------------------;
|
|
align 4
|
|
UDP_connect:
|
|
|
|
test [eax + SOCKET.state], SS_ISCONNECTED
|
|
jz @f
|
|
call UDP_disconnect
|
|
@@:
|
|
|
|
push eax edx
|
|
lea ecx, [eax + SOCKET.mutex]
|
|
call mutex_lock
|
|
pop edx eax
|
|
|
|
; Fill in local IP
|
|
cmp [eax + IP_SOCKET.LocalIP], 0
|
|
jne @f
|
|
push [IP_LIST + 4] ; FIXME: use correct local IP
|
|
pop [eax + IP_SOCKET.LocalIP]
|
|
|
|
; Fill in remote port and IP, overwriting eventually previous values
|
|
pushw [edx + 2]
|
|
pop [eax + UDP_SOCKET.RemotePort]
|
|
|
|
pushd [edx + 4]
|
|
pop [eax + IP_SOCKET.RemoteIP]
|
|
|
|
; Find a local port, if user didnt define one
|
|
cmp [eax + UDP_SOCKET.LocalPort], 0
|
|
jne @f
|
|
call SOCKET_find_port
|
|
@@:
|
|
|
|
push eax
|
|
lea ecx, [eax + SOCKET.mutex]
|
|
call mutex_unlock
|
|
pop eax
|
|
|
|
call SOCKET_is_connected
|
|
|
|
xor eax, eax
|
|
ret
|
|
|
|
|
|
;-----------------------------------------------------------------;
|
|
; ;
|
|
; UDP_disconnect ;
|
|
; ;
|
|
; IN: eax = socket pointer ;
|
|
; ;
|
|
; OUT: eax = socket pointer ;
|
|
; ;
|
|
;-----------------------------------------------------------------;
|
|
align 4
|
|
UDP_disconnect:
|
|
|
|
; TODO: remove the pending received data
|
|
|
|
call SOCKET_is_disconnected
|
|
|
|
ret
|
|
|
|
|
|
|
|
|
|
|
|
;-----------------------------------------------------------------;
|
|
; ;
|
|
; UDP_api: This function is called by system function 76 ;
|
|
; ;
|
|
; IN: bl = subfunction number in bl ;
|
|
; bh = device number in bh ;
|
|
; ecx, edx, .. depends on subfunction ;
|
|
; ;
|
|
; OUT: depends on subfunction ;
|
|
; ;
|
|
;-----------------------------------------------------------------;
|
|
align 4
|
|
UDP_api:
|
|
|
|
movzx eax, bh
|
|
shl eax, 2
|
|
|
|
test bl, bl
|
|
jz .packets_tx ; 0
|
|
dec bl
|
|
jz .packets_rx ; 1
|
|
|
|
.error:
|
|
mov eax, -1
|
|
ret
|
|
|
|
.packets_tx:
|
|
mov eax, [UDP_PACKETS_TX + eax]
|
|
ret
|
|
|
|
.packets_rx:
|
|
mov eax, [UDP_PACKETS_RX + eax]
|
|
ret
|