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

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/network/udp.inc – Rev 5201 → 5565