Subversion Repositories Kolibri OS

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

;;                                                                 ;;

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

IPv4_MAX_FRAGMENTS              = 64

IPv4_MAX_ROUTES                 = 64

IPv4_ROUTE_FLAG_UP              = 1 shl 0

IPv4_ROUTE_FLAG_GATEWAY         = 1 shl 1

IPv4_ROUTE_FLAG_HOST            = 1 shl 2

IPv4_ROUTE_FLAG_D               = 1 shl 3       ; Route was created by a redirect

IPv4_ROUTE_FLAG_M               = 1 shl 4       ; Route was modified by a redirect

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  IPv4_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  IPv4_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

struct  IPv4_ROUTE

        Destination             dd ?

        Gateway                 dd ?

        Flags                   dd ?

        Use                     dd ?

        Interface               dd ?

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

        IPv4_packets_tx         rd NET_DEVICES_MAX

        IPv4_packets_rx         rd NET_DEVICES_MAX

        IPv4_packets_dumped     rd NET_DEVICES_MAX

        IPv4_FRAGMENT_LIST      rb IPv4_MAX_FRAGMENTS * sizeof.IPv4_FRAGMENT_slot

        IPv4_ROUTES             rd IPv4_MAX_ROUTES * sizeof.IPv4_ROUTE

endg

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

;                                                                 ;

; ipv4_init: Resets all IPv4 variables                            ;

;                                                                 ;

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

macro   ipv4_init {

        xor     eax, eax

        mov     edi, IP_LIST

        mov     ecx, 7*NET_DEVICES_MAX + (sizeof.IPv4_FRAGMENT_slot*IPv4_MAX_FRAGMENTS)/4

        rep stosd

}

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

;                                                                 ;

; Decrease TimeToLive of all fragment slots                       ;

;                                                                 ;

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

macro ipv4_decrease_fragment_ttls {

local   .loop, .next

        mov     esi, IPv4_FRAGMENT_LIST

        mov     ecx, IPv4_MAX_FRAGMENTS

  .loop:

        cmp     [esi + IPv4_FRAGMENT_slot.ttl], 0

        je      .next

        dec     [esi + IPv4_FRAGMENT_slot.ttl]

        jz      .died

  .next:

        add     esi, sizeof.IPv4_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: Check if IPv4 Packet isnt damaged and call          ;

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

; We will also re-construct fragmented packets.                   ;

;                                                                 ;

;  IN:  Pointer to buffer in [esp]                                ;

;       pointer to device struct in ebx                           ;

;       pointer to IPv4 header in edx                             ;

;       size of IPv4 packet in ecx                                ;

;                                                                 ;

;  OUT: /                                                         ;

;                                                                 ;

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

align 4