WebSVN – Kolibri OS – Diff – /kernel/trunk/network/udp.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; 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: 6011 $
 
 
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: Part of 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

Rev 5976	Rev 6011
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2015. 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	;; UDP.INC ;;	6	;; UDP.INC ;;
7	;; ;;	7	;; ;;
8	;; Part of the tcp/ip network stack for KolibriOS ;;	8	;; Part of the tcp/ip network stack for KolibriOS ;;
9	;; ;;	9	;; ;;
10	;; Written by hidnplayr@kolibrios.org ;;	10	;; Written by hidnplayr@kolibrios.org ;;
11	;; ;;	11	;; ;;
12	;; GNU GENERAL PUBLIC LICENSE ;;	12	;; GNU GENERAL PUBLIC LICENSE ;;
13	;; Version 2, June 1991 ;;	13	;; Version 2, June 1991 ;;
14	;; ;;	14	;; ;;
15	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	15	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
16		16
17	$Revision: 5976 $	17	$Revision: 6011 $
18		18
19		19
20	struct UDP_header	20	struct UDP_header
21		21
22	SourcePort dw ?	22	SourcePort dw ?
23	DestinationPort dw ?	23	DestinationPort dw ?
24	Length dw ? ; Length of (UDP Header + Data)	24	Length dw ? ; Length of (UDP Header + Data)
25	Checksum dw ?	25	Checksum dw ?
26		26
27	ends	27	ends
28		28
29		29
30	uglobal	30	uglobal
31	align 4	31	align 4
32		32
33	UDP_PACKETS_TX rd NET_DEVICES_MAX	33	UDP_PACKETS_TX rd NET_DEVICES_MAX
34	UDP_PACKETS_RX rd NET_DEVICES_MAX	34	UDP_PACKETS_RX rd NET_DEVICES_MAX
35		35
36	endg	36	endg
37		37
38		38
39	;-----------------------------------------------------------------;	39	;-----------------------------------------------------------------;
40	; ;	40	; ;
41	; UDP_init: This function resets all UDP variables ;	41	; udp_init: This function resets all UDP variables ;
42	; ;	42	; ;
43	;-----------------------------------------------------------------;	43	;-----------------------------------------------------------------;
44	macro UDP_init {	44	macro udp_init {
45		45
46	xor eax, eax	46	xor eax, eax
47	mov edi, UDP_PACKETS_TX	47	mov edi, UDP_PACKETS_TX
48	mov ecx, 2*NET_DEVICES_MAX	48	mov ecx, 2*NET_DEVICES_MAX
49	rep stosd	49	rep stosd
50	}	50	}
51		51
52		52
53	macro UDP_checksum IP1, IP2 { ; esi = ptr to udp packet, ecx = packet size, destroys: ecx, edx	53	macro udp_checksum IP1, IP2 { ; esi = ptr to udp packet, ecx = packet size, destroys: ecx, edx
54		54
55	; Pseudoheader	55	; Pseudoheader
56	mov edx, IP_PROTO_UDP	56	mov edx, IP_PROTO_UDP
57		57
58	add dl, byte[IP1+1]	58	add dl, byte[IP1+1]
59	adc dh, byte[IP1+0]	59	adc dh, byte[IP1+0]
60	adc dl, byte[IP1+3]	60	adc dl, byte[IP1+3]
61	adc dh, byte[IP1+2]	61	adc dh, byte[IP1+2]
62		62
63	adc dl, byte[IP2+1]	63	adc dl, byte[IP2+1]
64	adc dh, byte[IP2+0]	64	adc dh, byte[IP2+0]
65	adc dl, byte[IP2+3]	65	adc dl, byte[IP2+3]
66	adc dh, byte[IP2+2]	66	adc dh, byte[IP2+2]
67		67
68	adc dl, cl ; byte[esi+UDP_header.Length+1]	68	adc dl, cl ; byte[esi+UDP_header.Length+1]
69	adc dh, ch ; byte[esi+UDP_header.Length+0]	69	adc dh, ch ; byte[esi+UDP_header.Length+0]
70		70
71	; Done with pseudoheader, now do real header	71	; Done with pseudoheader, now do real header
72	adc dl, byte[esi+UDP_header.SourcePort+1]	72	adc dl, byte[esi+UDP_header.SourcePort+1]
73	adc dh, byte[esi+UDP_header.SourcePort+0]	73	adc dh, byte[esi+UDP_header.SourcePort+0]
74		74
75	adc dl, byte[esi+UDP_header.DestinationPort+1]	75	adc dl, byte[esi+UDP_header.DestinationPort+1]
76	adc dh, byte[esi+UDP_header.DestinationPort+0]	76	adc dh, byte[esi+UDP_header.DestinationPort+0]
77		77
78	adc dl, byte[esi+UDP_header.Length+1]	78	adc dl, byte[esi+UDP_header.Length+1]
79	adc dh, byte[esi+UDP_header.Length+0]	79	adc dh, byte[esi+UDP_header.Length+0]
80		80
81	adc edx, 0	81	adc edx, 0
82		82
83	; Done with header, now do data	83	; Done with header, now do data
84	push esi	84	push esi
85	movzx ecx, [esi+UDP_header.Length]	85	movzx ecx, [esi+UDP_header.Length]
86	rol cx , 8	86	rol cx , 8
87	sub cx , sizeof.UDP_header	87	sub cx , sizeof.UDP_header
88	add esi, sizeof.UDP_header	88	add esi, sizeof.UDP_header
89		89
90	call checksum_1	90	call checksum_1
91	call checksum_2	91	call checksum_2
92	pop esi	92	pop esi
93		93
94	add [esi+UDP_header.Checksum], dx ; this final instruction will set or clear ZF :)	94	add [esi+UDP_header.Checksum], dx ; this final instruction will set or clear ZF :)
95		95
96	}	96	}
97		97
98		98
99	;-----------------------------------------------------------------;	99	;-----------------------------------------------------------------;
100	; ;	100	; ;
101	; UDP_input: Inject the UDP data in the application sockets. ;	101	; udp_input: Inject the UDP data in the application sockets. ;
102	; ;	102	; ;
103	; IN: [esp] = ptr to buffer ;	103	; IN: [esp] = ptr to buffer ;
104	; ebx = ptr to device struct ;	104	; ebx = ptr to device struct ;
105	; ecx = UDP packet size ;	105	; ecx = UDP packet size ;
106	; edx = ptr to IPv4 header ;	106	; edx = ptr to IPv4 header ;
107	; esi = ptr to UDP packet data ;	107	; esi = ptr to UDP packet data ;
108	; edi = interface number*4 ;	108	; edi = interface number*4 ;
109	; ;	109	; ;
110	; OUT: / ;	110	; OUT: / ;
111	; ;	111	; ;
112	;-----------------------------------------------------------------;	112	;-----------------------------------------------------------------;
113	align 4	113	align 4
114	UDP_input:	114	udp_input:
115		115
116	DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_input: size=%u\n", ecx	116	DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_input: size=%u\n", ecx
117		117
118	; First validate, checksum	118	; First validate, checksum
119		119
120	neg [esi + UDP_header.Checksum] ; substract checksum from 0	120	neg [esi + UDP_header.Checksum] ; substract checksum from 0
121	jz .no_checksum ; if checksum is zero, it is considered valid	121	jz .no_checksum ; if checksum is zero, it is considered valid
122		122
123	; otherwise, we will re-calculate the checksum and add it to this value, thus creating 0 when it is correct	123	; otherwise, we will re-calculate the checksum and add it to this value, thus creating 0 when it is correct
124		124
125	mov eax, edx	125	mov eax, edx
126	UDP_checksum (eax+IPv4_header.SourceAddress), (eax+IPv4_header.DestinationAddress)	126	udp_checksum (eax+IPv4_header.SourceAddress), (eax+IPv4_header.DestinationAddress)
127	jnz .checksum_mismatch	127	jnz .checksum_mismatch
128		128
129	.no_checksum:	129	.no_checksum:
130	DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_input: checksum ok\n"	130	DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_input: checksum ok\n"
131		131
132	; Convert length to little endian	132	; Convert length to little endian
133		133
134	rol [esi + UDP_header.Length], 8	134	rol [esi + UDP_header.Length], 8
135		135
136	; Look for a socket where	136	; Look for a socket where
137	; IP Packet UDP Destination Port = local Port	137	; IP Packet UDP Destination Port = local Port
138	; IP Packet SA = Remote IP	138	; IP Packet SA = Remote IP
139		139
140	pusha	140	pusha
141	mov ecx, socket_mutex	141	mov ecx, socket_mutex
142	call mutex_lock	142	call mutex_lock
143	popa	143	popa
144		144
145	mov cx, [esi + UDP_header.SourcePort]	145	mov cx, [esi + UDP_header.SourcePort]
146	mov dx, [esi + UDP_header.DestinationPort]	146	mov dx, [esi + UDP_header.DestinationPort]
147	mov eax, net_sockets	147	mov eax, net_sockets
148	.next_socket:	148	.next_socket:
149	mov eax, [eax + SOCKET.NextPtr]	149	mov eax, [eax + SOCKET.NextPtr]
150	or eax, eax	150	or eax, eax
151	jz .unlock_dump	151	jz .unlock_dump
152		152
153	cmp [eax + SOCKET.Domain], AF_INET4	153	cmp [eax + SOCKET.Domain], AF_INET4
154	jne .next_socket	154	jne .next_socket
155		155
156	cmp [eax + SOCKET.Protocol], IP_PROTO_UDP	156	cmp [eax + SOCKET.Protocol], IP_PROTO_UDP
157	jne .next_socket	157	jne .next_socket
158		158
159	cmp [eax + UDP_SOCKET.LocalPort], dx	159	cmp [eax + UDP_SOCKET.LocalPort], dx
160	jne .next_socket	160	jne .next_socket
161		161
162	DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_input: socket=%x\n", eax	162	DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_input: socket=%x\n", eax
163		163
164	pusha	164	pusha
165	mov ecx, socket_mutex	165	mov ecx, socket_mutex
166	call mutex_unlock	166	call mutex_unlock
167	popa	167	popa
168		168
169	;;; TODO: when packet is processed, check more sockets?!	169	;;; TODO: when packet is processed, check more sockets?!
170		170
171	; FIXME: check remote IP if possible	171	; FIXME: check remote IP if possible
172	;	172	;
173	; cmp [eax + IP_SOCKET.RemoteIP], 0xffffffff	173	; cmp [eax + IP_SOCKET.RemoteIP], 0xffffffff
174	; je @f	174	; je @f
175	; cmp [eax + IP_SOCKET.RemoteIP],	175	; cmp [eax + IP_SOCKET.RemoteIP],
176	; jne .next_socket	176	; jne .next_socket
177	; @@:	177	; @@:
178		178
179	cmp [eax + UDP_SOCKET.RemotePort], 0	179	cmp [eax + UDP_SOCKET.RemotePort], 0
180	je .updateport	180	je .updateport
181		181
182	cmp [eax + UDP_SOCKET.RemotePort], cx	182	cmp [eax + UDP_SOCKET.RemotePort], cx
183	jne .dump	183	jne .dump
184		184
185	pusha	185	pusha
186	lea ecx, [eax + SOCKET.mutex]	186	lea ecx, [eax + SOCKET.mutex]
187	call mutex_lock	187	call mutex_lock
188	popa	188	popa
189		189
190	.updatesock:	190	.updatesock:
191	inc [UDP_PACKETS_RX + edi]	191	inc [UDP_PACKETS_RX + edi]
192		192
193	movzx ecx, [esi + UDP_header.Length]	193	movzx ecx, [esi + UDP_header.Length]
194	sub ecx, sizeof.UDP_header	194	sub ecx, sizeof.UDP_header
195	add esi, sizeof.UDP_header	195	add esi, sizeof.UDP_header
196		196
197	jmp SOCKET_input	197	jmp socket_input
198		198
199	.updateport:	199	.updateport:
200	pusha	200	pusha
201	lea ecx, [eax + SOCKET.mutex]	201	lea ecx, [eax + SOCKET.mutex]
202	call mutex_lock	202	call mutex_lock
203	popa	203	popa
204		204
205	DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_input: new remote port=%x\n", cx ; FIXME: find a way to print big endian values with debugf	205	DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_input: new remote port=%x\n", cx ; FIXME: find a way to print big endian values with debugf
206	mov [eax + UDP_SOCKET.RemotePort], cx	206	mov [eax + UDP_SOCKET.RemotePort], cx
207	jmp .updatesock	207	jmp .updatesock
208		208
209	.unlock_dump:	209	.unlock_dump:
210	pusha	210	pusha
211	mov ecx, socket_mutex	211	mov ecx, socket_mutex
212	call mutex_unlock	212	call mutex_unlock
213	popa	213	popa
214		214
215	DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_input: no socket found\n"	215	DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_input: no socket found\n"
216	jmp .dump	216	jmp .dump
217		217
218	.checksum_mismatch:	218	.checksum_mismatch:
219	DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_input: checksum mismatch\n"	219	DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_input: checksum mismatch\n"
220		220
221	.dump:	221	.dump:
222	DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_input: dumping\n"	222	DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_input: dumping\n"
223	call NET_BUFF_free	223	call net_buff_free
224	ret	224	ret
225		225
226		226
227		227
228	;-----------------------------------------------------------------;	228	;-----------------------------------------------------------------;
229	; ;	229	; ;
230	; UDP_output: Create an UDP packet. ;	230	; udp_output: Create an UDP packet. ;
231	; ;	231	; ;
232	; IN: eax = socket pointer ;	232	; IN: eax = socket pointer ;
233	; ecx = number of bytes to send ;	233	; ecx = number of bytes to send ;
234	; esi = pointer to data ;	234	; esi = pointer to data ;
235	; ;	235	; ;
236	; OUT: eax = -1 on error ;	236	; OUT: eax = -1 on error ;
237	; ;	237	; ;
238	;-----------------------------------------------------------------;	238	;-----------------------------------------------------------------;
239		239
240	align 4	240	align 4
241	UDP_output:	241	udp_output:
242		242
243	DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_output: socket=%x bytes=%u data_ptr=%x\n", eax, ecx, esi	243	DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_output: socket=%x bytes=%u data_ptr=%x\n", eax, ecx, esi
244		244
245	mov dx, [eax + UDP_SOCKET.RemotePort]	245	mov dx, [eax + UDP_SOCKET.RemotePort]
246	DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_output: remote port=%x, ", dx ; FIXME: find a way to print big endian values with debugf	246	DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_output: remote port=%x, ", dx ; FIXME: find a way to print big endian values with debugf
247	rol edx, 16	247	rol edx, 16
248	mov dx, [eax + UDP_SOCKET.LocalPort]	248	mov dx, [eax + UDP_SOCKET.LocalPort]
249	DEBUGF DEBUG_NETWORK_VERBOSE, "local port=%x\n", dx	249	DEBUGF DEBUG_NETWORK_VERBOSE, "local port=%x\n", dx
250		250
251	sub esp, 4 ; Data ptr will be placed here	251	sub esp, 4 ; Data ptr will be placed here
252	push edx esi	252	push edx esi
253	mov ebx, [eax + IP_SOCKET.device]	253	mov ebx, [eax + IP_SOCKET.device]
254	mov edx, [eax + IP_SOCKET.LocalIP]	254	mov edx, [eax + IP_SOCKET.LocalIP]
255	mov edi, [eax + IP_SOCKET.RemoteIP]	255	mov edi, [eax + IP_SOCKET.RemoteIP]
256	mov al, [eax + IP_SOCKET.ttl]	256	mov al, [eax + IP_SOCKET.ttl]
257	mov ah, IP_PROTO_UDP	257	mov ah, IP_PROTO_UDP
258	add ecx, sizeof.UDP_header	258	add ecx, sizeof.UDP_header
259	call IPv4_output	259	call ipv4_output
260	jz .fail	260	jz .fail
261	mov [esp + 8], eax ; pointer to buffer start	261	mov [esp + 8], eax ; pointer to buffer start
262		262
263	mov [edi + UDP_header.Length], cx	263	mov [edi + UDP_header.Length], cx
264	rol [edi + UDP_header.Length], 8	264	rol [edi + UDP_header.Length], 8
265		265
266	pop esi	266	pop esi
267	push edi ecx	267	push edi ecx
268	sub ecx, sizeof.UDP_header	268	sub ecx, sizeof.UDP_header
269	add edi, sizeof.UDP_header	269	add edi, sizeof.UDP_header
270	shr ecx, 2	270	shr ecx, 2
271	rep movsd	271	rep movsd
272	mov ecx, [esp]	272	mov ecx, [esp]
273	and ecx, 3	273	and ecx, 3
274	rep movsb	274	rep movsb
275	pop ecx edi	275	pop ecx edi
276		276
277	pop dword [edi + UDP_header.SourcePort]	277	pop dword [edi + UDP_header.SourcePort]
278		278
279	; Checksum	279	; Checksum
280	mov esi, edi	280	mov esi, edi
281	mov [edi + UDP_header.Checksum], 0	281	mov [edi + UDP_header.Checksum], 0
282	UDP_checksum (edi-4), (edi-8) ; FIXME: IPv4 packet could have options..	282	udp_checksum (edi-4), (edi-8) ; FIXME: IPv4 packet could have options..
283		283
284	DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_output: sending with device %x\n", ebx	284	DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_output: sending with device %x\n", ebx
285	call [ebx + NET_DEVICE.transmit]	285	call [ebx + NET_DEVICE.transmit]
286	test eax, eax	286	test eax, eax
287	jnz @f	287	jnz @f
288	call NET_ptr_to_num4	288	call net_ptr_to_num4
289	inc [UDP_PACKETS_TX + edi]	289	inc [UDP_PACKETS_TX + edi]
290	@@:	290	@@:
291		291
292	ret	292	ret
293		293
294	.fail:	294	.fail:
295	DEBUGF DEBUG_NETWORK_ERROR, "UDP_output: failed\n"	295	DEBUGF DEBUG_NETWORK_ERROR, "UDP_output: failed\n"
296	add esp, 4+4+8	296	add esp, 4+4+8
297	or eax, -1	297	or eax, -1
298	ret	298	ret
299		299
300		300
301		301
302		302
303	;-----------------------------------------------------------------;	303	;-----------------------------------------------------------------;
304	; ;	304	; ;
305	; UDP_connect ;	305	; udp_connect ;
306	; ;	306	; ;
307	; IN: eax = socket pointer ;	307	; IN: eax = socket pointer ;
308	; ;	308	; ;
309	; OUT: eax = 0 on success ;	309	; OUT: eax = 0 on success ;
310	; eax = -1 on error ;	310	; eax = -1 on error ;
311	; ebx = error code on error ;	311	; ebx = error code on error ;
312	; ;	312	; ;
313	;-----------------------------------------------------------------;	313	;-----------------------------------------------------------------;
314	align 4	314	align 4
315	UDP_connect:	315	udp_connect:
316		316
317	test [eax + SOCKET.state], SS_ISCONNECTED	317	test [eax + SOCKET.state], SS_ISCONNECTED
318	jz @f	318	jz @f
319	call UDP_disconnect	319	call udp_disconnect
320	@@:	320	@@:
321		321
322	push eax edx	322	push eax edx
323	lea ecx, [eax + SOCKET.mutex]	323	lea ecx, [eax + SOCKET.mutex]
324	call mutex_lock	324	call mutex_lock
325	pop edx eax	325	pop edx eax
326		326
327	; Fill in local IP	327	; Fill in local IP
328	cmp [eax + IP_SOCKET.LocalIP], 0	328	cmp [eax + IP_SOCKET.LocalIP], 0
329	jne @f	329	jne @f
330	push [IP_LIST + 4] ; FIXME: use correct local IP	330	push [IP_LIST + 4] ; FIXME: use correct local IP
331	pop [eax + IP_SOCKET.LocalIP]	331	pop [eax + IP_SOCKET.LocalIP]
332		332
333	; Fill in remote port and IP, overwriting eventually previous values	333	; Fill in remote port and IP, overwriting eventually previous values
334	pushw [edx + 2]	334	pushw [edx + 2]
335	pop [eax + UDP_SOCKET.RemotePort]	335	pop [eax + UDP_SOCKET.RemotePort]
336		336
337	pushd [edx + 4]	337	pushd [edx + 4]
338	pop [eax + IP_SOCKET.RemoteIP]	338	pop [eax + IP_SOCKET.RemoteIP]
339		339
340	; Find a local port, if user didnt define one	340	; Find a local port, if user didnt define one
341	cmp [eax + UDP_SOCKET.LocalPort], 0	341	cmp [eax + UDP_SOCKET.LocalPort], 0
342	jne @f	342	jne @f
343	call SOCKET_find_port	343	call socket_find_port
344	@@:	344	@@:
345		345
346	push eax	346	push eax
347	lea ecx, [eax + SOCKET.mutex]	347	lea ecx, [eax + SOCKET.mutex]
348	call mutex_unlock	348	call mutex_unlock
349	pop eax	349	pop eax
350		350
351	call SOCKET_is_connected	351	call socket_is_connected
352		352
353	xor eax, eax	353	xor eax, eax
354	ret	354	ret
355		355
356		356
357	;-----------------------------------------------------------------;	357	;-----------------------------------------------------------------;
358	; ;	358	; ;
359	; UDP_disconnect ;	359	; UDP_disconnect ;
360	; ;	360	; ;
361	; IN: eax = socket pointer ;	361	; IN: eax = socket pointer ;
362	; ;	362	; ;
363	; OUT: eax = socket pointer ;	363	; OUT: eax = socket pointer ;
364	; ;	364	; ;
365	;-----------------------------------------------------------------;	365	;-----------------------------------------------------------------;
366	align 4	366	align 4
367	UDP_disconnect:	367	udp_disconnect:
368		368
369	; TODO: remove the pending received data	369	; TODO: remove the pending received data
370		370
371	call SOCKET_is_disconnected	371	call socket_is_disconnected
372		372
373	ret	373	ret
374		374
375		375
376		376
377		377
378		378
379	;-----------------------------------------------------------------;	379	;-----------------------------------------------------------------;
380	; ;	380	; ;
381	; UDP_api: This function is called by system function 76 ;	381	; UDP_api: Part of system function 76 ;
382	; ;	382	; ;
383	; IN: bl = subfunction number in bl ;	383	; IN: bl = subfunction number in bl ;
384	; bh = device number in bh ;	384	; bh = device number in bh ;
385	; ecx, edx, .. depends on subfunction ;	385	; ecx, edx, .. depends on subfunction ;
386	; ;	386	; ;
387	; OUT: depends on subfunction ;	387	; OUT: depends on subfunction ;
388	; ;	388	; ;
389	;-----------------------------------------------------------------;	389	;-----------------------------------------------------------------;
390	align 4	390	align 4
391	UDP_api:	391	udp_api:
392		392
393	movzx eax, bh	393	movzx eax, bh
394	shl eax, 2	394	shl eax, 2
395		395
396	test bl, bl	396	test bl, bl
397	jz .packets_tx ; 0	397	jz .packets_tx ; 0
398	dec bl	398	dec bl
399	jz .packets_rx ; 1	399	jz .packets_rx ; 1
400		400
401	.error:	401	.error:
402	mov eax, -1	402	mov eax, -1
403	ret	403	ret
404		404
405	.packets_tx:	405	.packets_tx:
406	mov eax, [UDP_PACKETS_TX + eax]	406	mov eax, [UDP_PACKETS_TX + eax]
407	ret	407	ret
408		408
409	.packets_rx:	409	.packets_rx:
410	mov eax, [UDP_PACKETS_RX + eax]	410	mov eax, [UDP_PACKETS_RX + eax]
411	ret	411	ret

Subversion Repositories Kolibri OS

(root)/kernel/trunk/network/udp.inc – Rev 5976 → 6011