Subversion Repositories Kolibri OS

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

;;                                                                 ;;

;; Copyright (C) KolibriOS team 2004-2012. All rights reserved.    ;;

;; Distributed under terms of the GNU General Public License       ;;

;;                                                                 ;;

;;  IPv4.INC                                                       ;;

;;                                                                 ;;

;;  Part of the TCP/IP network stack for KolibriOS                 ;;

;;                                                                 ;;

;;  Based on the work of [Johnny_B] and [smb]                      ;;

;;                                                                 ;;

;;    Written by hidnplayr@kolibrios.org                           ;;

;;                                                                 ;;

;;          GNU GENERAL PUBLIC LICENSE                             ;;

;;             Version 2, June 1991                                ;;

;;                                                                 ;;

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

$Revision: 3515 $

MAX_FRAGMENTS                   = 64

struct  IPv4_header

        VersionAndIHL           db ?    ; Version[0-3 bits] and IHL(header length)[4-7 bits]

        TypeOfService           db ?    ; precedence [7-5] minimize delay [4], maximize throughput [3], maximize riliability [2] minimize momentary cost [1] and zero [0]

        TotalLength             dw ?

        Identification          dw ?

        FlagsAndFragmentOffset  dw ?    ; Flags[0-2] and FragmentOffset[3-15]

        TimeToLive              db ?    ;

        Protocol                db ?

        HeaderChecksum          dw ?

        SourceAddress           dd ?

        DestinationAddress      dd ?

ends

struct  FRAGMENT_slot

        ttl                     dw ?    ; Time to live for this entry, 0 for empty slot's

        id                      dw ?    ; Identification field from IP header

        SrcIP                   dd ?    ; .. from IP header

        DstIP                   dd ?    ; .. from IP header

        ptr                     dd ?    ; Pointer to first packet

ends

struct  FRAGMENT_entry                  ; This structure will replace the ethernet header in fragmented ip packets

        PrevPtr                 dd ?    ; Pointer to previous fragment entry  (-1 for first packet)

        NextPtr                 dd ?    ; Pointer to next fragment entry (-1 for last packet)

        Owner                   dd ?    ; Pointer to structure of driver

                                rb 2    ; to match ethernet header size         ;;; FIXME

                                        ; Ip header begins here (we will need the IP header to re-construct the complete packet)

ends

uglobal

align 4

        IP_LIST                 rd NET_DEVICES_MAX

        SUBNET_LIST             rd NET_DEVICES_MAX

        DNS_LIST                rd NET_DEVICES_MAX

        GATEWAY_LIST            rd NET_DEVICES_MAX

        BROADCAST_LIST          rd NET_DEVICES_MAX

        IP_packets_tx           rd NET_DEVICES_MAX

        IP_packets_rx           rd NET_DEVICES_MAX

        IP_packets_dumped       rd NET_DEVICES_MAX

        FRAGMENT_LIST           rb MAX_FRAGMENTS * sizeof.FRAGMENT_slot

endg

;-----------------------------------------------------------------

;

; IPv4_init

;

;  This function resets all IP variables

;

;-----------------------------------------------------------------

macro   IPv4_init {

        xor     eax, eax

        mov     edi, IP_LIST

        mov     ecx, 7*NET_DEVICES_MAX + (sizeof.FRAGMENT_slot*MAX_FRAGMENTS)/4

        rep stosd

}

;-----------------------------------------------------------------

;

; Decrease TimeToLive of all fragment slots

;

;-----------------------------------------------------------------

macro IPv4_decrease_fragment_ttls {

local   .loop, .next

        mov     esi, FRAGMENT_LIST

        mov     ecx, MAX_FRAGMENTS

  .loop:

        cmp     [esi + FRAGMENT_slot.ttl], 0

        je      .next

        dec     [esi + FRAGMENT_slot.ttl]

        jz      .died

  .next:

        add     esi, sizeof.FRAGMENT_slot

        dec     ecx

        jnz     .loop

        jmp     .done

  .died:

        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4 Fragment slot timed-out!\n"

;;; TODO: clear all entry's of timed-out slot

        jmp     .next

  .done:

}

macro IPv4_checksum ptr {

; This is the fast procedure to create or check an IP header without options

; To create a new checksum, the checksum field must be set to 0 before computation

; To check an existing checksum, leave the checksum as is, and it will be 0 after this procedure, if it was correct

        push    ebx

        xor     ebx, ebx

        add     bl, [ptr+1]

        adc     bh, [ptr+0]

        adc     bl, [ptr+3]

        adc     bh, [ptr+2]

        adc     bl, [ptr+5]

        adc     bh, [ptr+4]

        adc     bl, [ptr+7]

        adc     bh, [ptr+6]

        adc     bl, [ptr+9]

        adc     bh, [ptr+8]

; we skip 11th and 12th byte, they are the checksum bytes and should be 0 for re-calculation

        adc     bl, [ptr+13]

        adc     bh, [ptr+12]

        adc     bl, [ptr+15]

        adc     bh, [ptr+14]

        adc     bl, [ptr+17]

        adc     bh, [ptr+16]

        adc     bl, [ptr+19]

        adc     bh, [ptr+18]

        adc     ebx, 0

        push    ecx

        mov     ecx, ebx

        shr     ecx, 16

        and     ebx, 0xffff

        add     ebx, ecx

        mov     ecx, ebx

        shr     ecx, 16

        add     ebx, ecx

        not     bx

        jnz     .not_zero

        dec     bx

  .not_zero:

        xchg    bl, bh

        pop     ecx

        neg     word [ptr+10]           ; zero will stay zero so we just get the checksum

        add     word [ptr+10], bx       ;  , else we will get (new checksum - old checksum) in the end, wich should be 0 :)

        pop     ebx

}

;-----------------------------------------------------------------

;

; IPv4_input:

;

;  Will check if IPv4 Packet isnt damaged

;  and call appropriate handler. (TCP/UDP/ICMP/..)

;

;  It will also re-construct fragmented packets

;

;  IN:  Pointer to buffer in [esp]

;       size of buffer in [esp+4]

;       pointer to device struct in ebx

;       pointer to IPv4 header in edx

;       size of IPv4 packet in ecx

;  OUT: /

;

;-----------------------------------------------------------------

align 4

IPv4_input:                                                     ; TODO: add IPv4 raw sockets support

        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_input, packet from: %u.%u.%u.%u ",\

        [edx + IPv4_header.SourceAddress + 0]:1,[edx + IPv4_header.SourceAddress + 1]:1,\

        [edx + IPv4_header.SourceAddress + 2]:1,[edx + IPv4_header.SourceAddress + 3]:1

        DEBUGF  DEBUG_NETWORK_VERBOSE, "to: %u.%u.%u.%u\n",\

        [edx + IPv4_header.DestinationAddress + 0]:1,[edx + IPv4_header.DestinationAddress + 1]:1,\

        [edx + IPv4_header.DestinationAddress + 2]:1,[edx + IPv4_header.DestinationAddress + 3]:1

;-------------------------------

; re-calculate the checksum

        IPv4_checksum edx

        jnz     .dump                                           ; if checksum isn't valid then dump packet

        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_input: Checksum ok\n"

;-----------------------------------

; Check if destination IP is correct

        call    NET_ptr_to_num4

        ; check if it matches local ip (Using RFC1122 strong end system model)

        mov     eax, [edx + IPv4_header.DestinationAddress]

        cmp     eax, [IP_LIST + edi]

        je      .ip_ok

        ; check for broadcast (IP or (not SUBNET))

        cmp     eax, [BROADCAST_LIST + edi]

        je      .ip_ok

        ; or a special broadcast (255.255.255.255)

        cmp     eax, 0xffffffff

        je      .ip_ok

        ; mayb