Subversion Repositories Kolibri OS

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;                                                                 ;;

;; Copyright (C) KolibriOS team 2004-2019. 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: 9739 $

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