WebSVN – Kolibri OS – Diff – /kernel/branches/Kolibri-acpi/network/IPv4.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2014. 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 $
 
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
;
;  This function resets all IP 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:
;
;  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
 
        ; maybe it's a multicast (224.0.0.0/4)
 
        and     eax, 0x0fffffff
        cmp     eax, 224
        je      .ip_ok
 
 
        ; maybe we just dont have an IP yet and should accept everything on the IP level
 
        cmp     [IP_LIST + edi], 0
        je      .ip_ok
 
        ; or it's just not meant for us.. :(
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_input: Destination address does not match!\n"
        jmp     .dump
 
;------------------------
; Now we can update stats
 
  .ip_ok:
        inc     [IPv4_packets_rx + edi]
 
;----------------------------------
; Check if the packet is fragmented
 
        test    [edx + IPv4_header.FlagsAndFragmentOffset], 1 shl 5     ; Is 'more fragments' flag set ?
        jnz     .has_fragments                                          ; If so, we definately have a fragmented packet
 
        test    [edx + IPv4_header.FlagsAndFragmentOffset], 0xff1f      ; If flag is not set, but there is a fragment offset, the packet is last in series of fragmented packets
        jnz     .is_last_fragment
 
;-------------------------------------------------------------------
; No, it's just a regular IP packet, pass it to the higher protocols
 
  .handle_it:                                                   ; We reach here if packet hasnt been fragmented, or when it already has been re-constructed
 
        movzx   esi, [edx + IPv4_header.VersionAndIHL]          ; Calculate Header length by using IHL field
        and     esi, 0x0000000f                                 ;
        shl     esi, 2                                          ;
 
        movzx   ecx, [edx + IPv4_header.TotalLength]            ; Calculate length of encapsulated Packet
        xchg    cl, ch                                          ;
        sub     ecx, esi                                        ;
 
        lea     edi, [edx + IPv4_header.SourceAddress]          ; make edi ptr to source and dest IPv4 address
        mov     al, [edx + IPv4_header.Protocol]
        add     esi, edx                                        ; make esi ptr to data
 
        cmp     al, IP_PROTO_TCP
        je      TCP_input
 
        cmp     al, IP_PROTO_UDP
        je      UDP_input
 
        cmp     al, IP_PROTO_ICMP
        je      ICMP_input
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_input: unknown protocol %u\n", al
 
  .dump:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_input: dumping\n"
        inc     [IPv4_packets_dumped]                           ; FIXME: use correct interface
        call    NET_packet_free
        add     esp, 4                                          ; pop (balance stack)
        ret
 
 
;---------------------------
; Fragmented packet handler
 
 
  .has_fragments:
        movzx   eax, [edx + IPv4_header.FlagsAndFragmentOffset]
        xchg    al, ah
        shl     ax, 3
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_input: fragmented packet offset=%u id=%x ptr=0x%x\n", ax, [edx + IPv4_header.Identification]:4, edx
 
        test    ax, ax                                          ; Is this the first packet of the fragment?
        jz      .is_first_fragment
 
 
;-------------------------------------------------------
; We have a fragmented IP packet, but it's not the first
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_input: Middle fragment packet received!\n"
 
        call    IPv4_find_fragment_slot
        cmp     esi, -1
        je      .dump
 
        mov     [esi + IPv4_FRAGMENT_slot.ttl], 15              ; Reset the ttl
        mov     esi, [esi + IPv4_FRAGMENT_slot.ptr]
        or      edi, -1
  .find_last_entry:                                             ; The following routine will try to find the last entry
        cmp     edi, [esi + IPv4_FRAGMENT_entry.PrevPtr]
        jne     .destroy_slot                                   ; Damn, something screwed up, remove the whole slot (and free buffers too if possible!)
        mov     edi, esi
        mov     esi, [esi + IPv4_FRAGMENT_entry.NextPtr]
        cmp     esi, -1
        jne     .find_last_entry
                                                                ; We found the last entry (pointer is now in edi)
                                                                ; We are going to overwrite the ethernet header in received packet with a FRAGMENT_entry structure
 
        pop     eax                                             ; pointer to packet
        mov     [edi + IPv4_FRAGMENT_entry.NextPtr], eax        ; update pointer of previous entry to the new entry
        mov     [eax + IPv4_FRAGMENT_entry.NextPtr], -1
        mov     [eax + IPv4_FRAGMENT_entry.PrevPtr], edi
        mov     [eax + IPv4_FRAGMENT_entry.Owner], ebx
 
        add     esp, 4
        ret
 
 
;------------------------------------
; We have received the first fragment
 
  .is_first_fragment:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_input: First fragment packet received!\n"
                                                                ; try to locate a free slot..
        mov     ecx, IPv4_MAX_FRAGMENTS
        mov     esi, IPv4_FRAGMENT_LIST
  .find_free_slot:
        cmp     word [esi + IPv4_FRAGMENT_slot.ttl], 0
        je      .found_free_slot
        add     esi, sizeof.IPv4_FRAGMENT_slot
        loop    .find_free_slot
        jmp     .dump                                           ; If no free slot was found, dump the packet
 
  .found_free_slot:                                             ; We found a free slot, let's fill in the FRAGMENT_slot structure
        mov     [esi + IPv4_FRAGMENT_slot.ttl], 15              ; RFC recommends 15 secs as ttl
        mov     ax, [edx + IPv4_header.Identification]
        mov     [esi + IPv4_FRAGMENT_slot.id], ax
        mov     eax, [edx + IPv4_header.SourceAddress]
        mov     [esi + IPv4_FRAGMENT_slot.SrcIP], eax
        mov     eax, [edx + IPv4_header.DestinationAddress]
        mov     [esi + IPv4_FRAGMENT_slot.DstIP], eax
        pop     eax
        mov     [esi + IPv4_FRAGMENT_slot.ptr], eax
                                                                ; Now, replace ethernet header in original buffer with a FRAGMENT_entry structure
        mov     [eax + IPv4_FRAGMENT_entry.NextPtr], -1
        mov     [eax + IPv4_FRAGMENT_entry.PrevPtr], -1
        mov     [eax + IPv4_FRAGMENT_entry.Owner], ebx
 
        add     esp, 4                                          ; balance stack and exit
        ret
 
 
;-----------------------------------
; We have received the last fragment
 
  .is_last_fragment:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_input: Last fragment packet received!\n"
 
        call    IPv4_find_fragment_slot
        cmp     esi, -1
        je      .dump
 
        mov     esi, [esi + IPv4_FRAGMENT_slot.ptr]                     ; We found the first entry, let's calculate total size of the packet in eax, so we can allocate a buffer
        push    esi
        xor     eax, eax
        or      edi, -1
 
  .count_bytes:
        cmp     [esi + IPv4_FRAGMENT_entry.PrevPtr], edi
        jne     .destroy_slot_pop                                                       ; Damn, something screwed up, remove the whole slot (and free buffers too if possible!)
        mov     cx, [esi + sizeof.IPv4_FRAGMENT_entry + IPv4_header.TotalLength]        ; Add total length
        xchg    cl, ch
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_input: Packet size=%u\n", cx
        add     ax, cx
        movzx   cx, [esi + sizeof.IPv4_FRAGMENT_entry + IPv4_header.VersionAndIHL]      ; Sub Header length
        and     cx, 0x000F
        shl     cx, 2
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_input: Header size=%u\n", cx
        sub     ax, cx
        mov     edi, esi
        mov     esi, [esi + IPv4_FRAGMENT_entry.NextPtr]
        cmp     esi, -1
        jne     .count_bytes
 
        mov     esi, [esp+4]
        mov     [edi + IPv4_FRAGMENT_entry.NextPtr], esi                                ; Add this packet to the chain, this simplifies the following code
        mov     [esi + IPv4_FRAGMENT_entry.NextPtr], -1
        mov     [esi + IPv4_FRAGMENT_entry.PrevPtr], edi
        mov     [esi + IPv4_FRAGMENT_entry.Owner], ebx
 
        mov     cx, [edx + IPv4_header.TotalLength]                                     ; Note: This time we dont substract Header length
        xchg    cl, ch
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_input: Packet size=%u\n", cx
        add     ax, cx
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_input: Total Received data size=%u\n", eax
 
        push    eax
        mov     ax, [edx + IPv4_header.FlagsAndFragmentOffset]
        xchg    al, ah
        shl     ax, 3
        add     cx, ax
        pop     eax
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_input: Total Fragment size=%u\n", ecx
 
        cmp     ax, cx
        jne     .destroy_slot_pop
 
        push    eax
        push    eax
        call    kernel_alloc
        test    eax, eax
        je      .destroy_slot_pop                                                       ; If we dont have enough space to allocate the buffer, discard all packets in slot
        mov     edx, [esp+4]                                                            ; Get pointer to first fragment entry back in edx
 
  .rebuild_packet_loop:
        movzx   ecx, [edx + sizeof.IPv4_FRAGMENT_entry + IPv4_header.FlagsAndFragmentOffset] ; Calculate the fragment offset
        xchg    cl, ch                                                                  ;  intel byte order
        shl     cx, 3                                                                   ;   multiply by 8 and clear first 3 bits
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_input: Fragment offset=%u\n", cx
 
        lea     edi, [eax + ecx]                                                        ; Notice that edi will be equal to eax for first fragment
        movzx   ebx, [edx + sizeof.IPv4_FRAGMENT_entry + IPv4_header.VersionAndIHL]     ; Find header size (in ebx) of fragment
        and     bx, 0x000F                                                              ;
        shl     bx, 2                                                                   ;
 
        lea     esi, [edx + sizeof.IPv4_FRAGMENT_entry]                                 ; Set esi to the correct begin of fragment
        movzx   ecx, [edx + sizeof.IPv4_FRAGMENT_entry + IPv4_header.TotalLength]       ; Calculate total length of fragment
        xchg    cl, ch                                                                  ;  intel byte order
 
        cmp     edi, eax                                                                ; Is this packet the first fragment ?
        je      .first_fragment
        sub     cx, bx                                                                  ; If not, dont copy the header
        add     esi, ebx                                                                ;
  .first_fragment:
 
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_input: Copying %u bytes from 0x%x to 0x%x\n", ecx, esi, edi
        push    cx                                                                      ; First copy dword-wise, then byte-wise
        shr     cx, 2                                                                   ;
        rep movsd                                                                       ;
        pop     cx                                                                      ;
        and     cx, 3                                                                   ;
        rep movsb                                                                       ;
 
        push    eax
        push    [edx + IPv4_FRAGMENT_entry.Owner]                                       ; we need to remeber the owner, in case this is the last packet
        push    [edx + IPv4_FRAGMENT_entry.NextPtr]                                     ; Set edx to the next pointer
        push    edx                                                                     ; Push pointer to fragment onto stack
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_input: Next Fragment: 0x%x\n", edx
        call    NET_packet_free                                                         ; free the previous fragment buffer (this uses the value from stack)
        pop     edx ebx eax
        cmp     edx, -1                                                                 ; Check if it is last fragment in chain
        jne     .rebuild_packet_loop
 
        pop     ecx
        xchg    cl, ch
        mov     edx, eax
        mov     [edx + IPv4_header.TotalLength], cx
        add     esp, 12
        xchg    cl, ch
        push    ecx edx                 ; size and pointer
        jmp     .handle_it              ; edx = buf ptr, ecx = size, [esp] buf ptr, [esp+4], total size, ebx=device ptr
 
  .destroy_slot_pop:
        add     esp, 4
  .destroy_slot:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_input: Destroy fragment slot!\n"
        ; TODO!
        jmp     .dump
 
 
 
 
 
;-----------------------------------------------------------------
;
; find fragment slot
;
; IN: pointer to fragmented packet in edx
; OUT: pointer to slot in esi, -1 on error
;
;-----------------------------------------------------------------
align 4
IPv4_find_fragment_slot:
 
;;; TODO: the RFC says we should check protocol number too
 
        push    eax ebx ecx edx
        mov     ax, [edx + IPv4_header.Identification]
        mov     ecx, IPv4_MAX_FRAGMENTS
        mov     esi, IPv4_FRAGMENT_LIST
        mov     ebx, [edx + IPv4_header.SourceAddress]
        mov     edx, [edx + IPv4_header.DestinationAddress]
  .find_slot:
        cmp     [esi + IPv4_FRAGMENT_slot.id], ax
        jne     .try_next
        cmp     [esi + IPv4_FRAGMENT_slot.SrcIP], ebx
        jne     .try_next
        cmp     [esi + IPv4_FRAGMENT_slot.DstIP], edx
        je      .found_slot
  .try_next:
        add     esi, sizeof.IPv4_FRAGMENT_slot
        loop    .find_slot
 
        or      esi, -1
  .found_slot:
        pop     edx ecx ebx eax
        ret
 
 
;------------------------------------------------------------------
;
; IPv4_output
;
; IN:   eax = Destination IP
;       ecx = data length
;       edx = Source IP
;       di  = TTL shl 8 + protocol
;
; OUT:  eax = pointer to buffer start / 0 on error
;       ebx = device ptr (send packet through this device)
;       ecx = data length
;       edx = size of complete frame
;       edi = start of IPv4 payload
;
;------------------------------------------------------------------
align 4
IPv4_output:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_output: size=%u ip=0x%x\n", ecx, eax
 
        cmp     ecx, 65500              ; Max IPv4 packet size
        ja      .too_large
 
        push    ecx di eax
        call    IPv4_route              ; outputs device number in edi, dest ip in eax, source IP in edx
        push    edx
 
        test    edi, edi
        jz      .loopback
 
        call    ARP_IP_to_MAC
        test    eax, 0xffff0000         ; error bits
        jnz     .arp_error
        push    ebx                     ; push the mac onto the stack
        push    ax
 
        inc     [IPv4_packets_tx + edi]   ; update stats
 
        mov     ax, ETHER_PROTO_IPv4
 
 
        mov     ebx, [NET_DRV_LIST + edi]
        mov     ecx, [esp + 6 + 8 + 2]
        add     ecx, sizeof.IPv4_header
        mov     edx, esp
        call    ETH_output
        jz      .eth_error
        add     esp, 6                  ; pop the mac out of the stack
 
  .continue:
        xchg    cl, ch                                  ; internet byte order
        mov     [edi + IPv4_header.VersionAndIHL], 0x45 ; IPv4, normal length (no Optional header)
        mov     [edi + IPv4_header.TypeOfService], 0    ; nothing special, just plain ip packet
        mov     [edi + IPv4_header.TotalLength], cx
        mov     [edi + IPv4_header.Identification], 0   ; fragment id: FIXME
        mov     [edi + IPv4_header.FlagsAndFragmentOffset], 0
 
        mov     [edi + IPv4_header.HeaderChecksum], 0
        popd    [edi + IPv4_header.SourceAddress]
        popd    [edi + IPv4_header.DestinationAddress]
 
        pop     word[edi + IPv4_header.TimeToLive]      ; ttl shl 8 + protocol
;               [edi + IPv4_header.Protocol]
 
        pop     ecx
 
        IPv4_checksum edi
        add     edi, sizeof.IPv4_header
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_output: success!\n"
        ret
 
  .eth_error:
        DEBUGF  DEBUG_NETWORK_ERROR, "IPv4_output: ethernet error\n"
        add     esp, 3*4+2+6
        xor     eax, eax
        ret
 
  .arp_error:
        DEBUGF  DEBUG_NETWORK_ERROR, "IPv4_output: ARP error=%x\n", eax
        add     esp, 3*4+2
        xor     eax, eax
        ret
 
  .too_large:
        DEBUGF  DEBUG_NETWORK_ERROR, "IPv4_output: Packet too large!\n"
        xor     eax, eax
        ret
 
  .loopback:
        mov     dword [esp + 2], eax            ; change source IP to dest IP
        mov     ecx, [esp + 10]
        add     ecx, sizeof.IPv4_header
        mov     edi, AF_INET4
        call    LOOP_output
        jmp     .continue
 
 
 
 
;------------------------------------------------------------------
;
; IPv4_output_raw
;
; IN: eax = socket ptr
;     ecx = data length
;     esi = data ptr
;
; OUT: eax = -1 on error
;
;------------------------------------------------------------------
align 4
IPv4_output_raw:
 
        DEBUGF 1,"IPv4_output_raw: size=%u ptr=%x socket=%x\n", ecx, esi, eax
 
        cmp     ecx, 1480               ;;;;; FIXME
        ja      .too_large
 
        sub     esp, 8
        push    esi eax
 
        call    IPv4_route
        call    ARP_IP_to_MAC
 
        test    eax, 0xffff0000         ; error bits
        jnz     .arp_error
 
        push    ebx                     ; push the mac
        push    ax
 
        inc     [IPv4_packets_tx + 4*edi]
        mov     ax, ETHER_PROTO_IPv4
        mov     ebx, [NET_DRV_LIST + 4*edi]
 
 
        mov     ecx, [esp + 6 + 4]
        add     ecx, sizeof.IPv4_header
        mov     edx, esp
        call    ETH_output
        jz      .error
 
        add     esp, 6  ; pop the mac
 
        mov     dword[esp+4+4], edx
        mov     dword[esp+4+4+4], eax
 
        pop     eax esi
;; todo: check socket options if we should add header, or just compute checksum
 
        push    edi ecx
        rep movsb
        pop     ecx edi
 
;        [edi + IPv4_header.VersionAndIHL]              ; IPv4, normal length (no Optional header)
;        [edi + IPv4_header.TypeOfService]              ; nothing special, just plain ip packet
;        [edi + IPv4_header.TotalLength]
;        [edi + IPv4_header.TotalLength]                ; internet byte order
;        [edi + IPv4_header.FlagsAndFragmentOffset]
 
        mov     [edi + IPv4_header.HeaderChecksum], 0
 
;        [edi + IPv4_header.TimeToLive]                 ; ttl shl 8 + protocol
;        [edi + IPv4_header.Protocol]
;        [edi + IPv4_header.Identification]             ; fragment id
;        [edi + IPv4_header.SourceAddress]
;        [edi + IPv4_header.DestinationAddress]
 
        IPv4_checksum edi                       ;;;; todo: checksum for IP packet with options!
        add     edi, sizeof.IPv4_header
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_output_raw: device=%x\n", ebx
        call    [ebx + NET_DEVICE.transmit]
        ret
 
  .error:
        add     esp, 6
  .arp_error:
        add     esp, 8+4+4
  .too_large:
        DEBUGF  DEBUG_NETWORK_ERROR, "IPv4_output_raw: Failed\n"
        or      eax, -1
        ret
 
 
;--------------------------------------------------------
;
;
; IN: dword [esp] = pointer to buffer containing ipv4 packet to be fragmented
;     dword [esp+4] = buffer size
;     esi = pointer to ip header in that buffer
;     ecx = max size of fragments
;
; OUT: /
;
;--------------------------------------------------------
 
align 4
IPv4_fragment:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_fragment\n"
 
        and     ecx, not 111b   ; align 4
 
        cmp     ecx, sizeof.IPv4_header + 8     ; must be able to put at least 8 bytes
        jb      .err2
 
        push    esi ecx
        mov     eax, [esi + IPv4_header.DestinationAddress]
        call    ARP_IP_to_MAC
        pop     ecx esi
        cmp     eax, -1
        jz      .err2
 
        push    ebx
        push    ax
 
        mov     ebx, [NET_DRV_LIST]
        lea     eax, [ebx + ETH_DEVICE.mac]
        push    eax
 
 
        push    esi                             ; ptr to ip header
        sub     ecx, sizeof.IPv4_header         ; substract header size
        push    ecx                             ; max data size
        push    dword 0                         ; offset
 
  .new_fragment:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "Ipv4_fragment: new fragment"
 
 
        mov     ax, ETHER_PROTO_IPv4
 
        lea     ebx, [esp + 4*4]
 
 
        call    ETH_output
        jz      .err
 
; copy header
        mov     esi, [esp + 2*4]
        mov     ecx, 5  ; 5 dwords: TODO: use IHL field of the header!
        rep movsd
 
; copy data
        mov     esi, [esp + 2*4]
        add     esi, sizeof.IPv4_header
        add     esi, [esp]      ; offset
 
        mov     ecx, [esp + 1*4]
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_fragment: copying %u bytes\n", ecx
        rep movsb
 
; now, correct header
        mov     ecx, [esp + 1*4]
        add     ecx, sizeof.IPv4_header
        xchg    cl, ch
        mov     [edi + IPv4_header.TotalLength], cx
 
        mov     ecx, [esp]              ; offset
        xchg    cl, ch
 
;        cmp     dword[esp + 4*4], 0     ; last fragment?;<<<<<<
;        je      .last_fragment
        or      cx, 1 shl 2             ; more fragments
;  .last_fragment:
        mov     [edi + IPv4_header.FlagsAndFragmentOffset], cx
 
        mov     [edi + IPv4_header.HeaderChecksum], 0
 
        ;<<<<<<<<<<<<<<<<<<<<<<<<<<<<< send the packet
        mov     ecx, [esp + 1*4]
 
        push    edx eax
        IPv4_checksum edi
 
        call    [ebx + NET_DEVICE.transmit]
        ;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
 
        mov     ecx, [esp+4]
        add     [esp], ecx
 
        mov     ecx, [esp+3*4+6+4]      ; ptr to begin of buff
        add     ecx, [esp+3*4+6+4+4]    ; buff size
        sub     ecx, [esp+2*4]          ; ptr to ip header
        add     ecx, [esp]              ; offset
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "Ipv4_fragment: %u bytes remaining\n", ecx
 
        cmp     ecx, [esp+1*4]
        jae     .new_fragment
 
        mov     [esp+4], ecx            ; set fragment size to remaining packet size
        jmp     .new_fragment
 
      .err:
        DEBUGF  DEBUG_NETWORK_ERROR, "Ipv4_fragment: failed\n"
      .done:
        add     esp, 12 + 4 + 6
      .err2:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "Ipv4_fragment: dumping\n"
        call    NET_packet_free
        add     esp, 4
 
        ret
 
 
 
;---------------------------------------------------------------------------
;
; IPv4_route
;
; IN:   eax = Destination IP
;       edx = Source IP
; OUT:  eax = Destination IP (or gateway IP)
;       edx = Source IP
;       edi = device number*4
; DESTROYED:
;       ecx
;
;---------------------------------------------------------------------------
align 4
IPv4_route:     ; TODO: return error if no valid route found
 
        cmp     eax, 0xffffffff
        je      .broadcast
 
        xor     edi, edi
  .loop:
        mov     ebx, [IP_LIST + edi]
        and     ebx, [SUBNET_LIST + edi]
        jz      .next
        mov     ecx, eax
        and     ecx, [SUBNET_LIST + edi]
        cmp     ebx, ecx
        je      .got_it
  .next:
        add     edi, 4
        cmp     edi, 4*NET_DEVICES_MAX
        jb      .loop
 
        mov     eax, [GATEWAY_LIST + 4]         ; TODO: let user (or a user space daemon) configure default route
  .broadcast:
        mov     edi, 4                          ; TODO: same as above
  .got_it:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_route: %u\n", edi
        test    edx, edx
        jnz     @f
        mov     edx, [IP_LIST + edi]
  @@:
 
        ret
 
 
 
;---------------------------------------------------------------------------
;
; IPv4_get_frgmnt_num
;
; IN: /
; OUT: fragment number in ax
;
;---------------------------------------------------------------------------
align 4
IPv4_get_frgmnt_num:
        xor     ax, ax  ;;; TODO: replace this with real code
 
        ret
 
 
;-----------------------------------------------------------------
;
; IPv4_connect
;
;   IN: eax = socket pointer
;  OUT: eax = 0 ok / -1 error
;       ebx = error code
;
;-------------------------
align 4
IPv4_connect:
 
        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 IP
        pushd   [edx + 4]
        pop     [eax + IP_SOCKET.RemoteIP]
 
; Set up data receiving queue
        push    eax
        init_queue (eax + SOCKET_QUEUE_LOCATION)
        pop     eax
 
        lea     ecx, [eax + SOCKET.mutex]
        call    mutex_unlock
 
        xor     eax, eax
        ret
 
 
;---------------------------------------------------------------------------
;
; IPv4_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
IPv4_api:
 
        movzx   eax, bh
        shl     eax, 2
 
        and     ebx, 0x000000ff
        cmp     ebx, .number
        ja      .error
        jmp     dword [.table + 4*ebx]
 
  .table:
        dd      .packets_tx     ; 0
        dd      .packets_rx     ; 1
        dd      .read_ip        ; 2
        dd      .write_ip       ; 3
        dd      .read_dns       ; 4
        dd      .write_dns      ; 5
        dd      .read_subnet    ; 6
        dd      .write_subnet   ; 7
        dd      .read_gateway   ; 8
        dd      .write_gateway  ; 9
  .number = ($ - .table) / 4 - 1
 
  .error:
        mov     eax, -1
        ret
 
  .packets_tx:
        mov     eax, [IPv4_packets_tx + eax]
        ret
 
  .packets_rx:
        mov     eax, [IPv4_packets_rx + eax]
        ret
 
  .read_ip:
        mov     eax, [IP_LIST + eax]
        ret
 
  .write_ip:
        mov     [IP_LIST + eax], ecx
        mov     edi, eax                        ; device number, we'll need it for ARP
 
        ; pre-calculate the local broadcast address
        mov     ebx, [SUBNET_LIST + eax]
        not     ebx
        or      ebx, ecx
        mov     [BROADCAST_LIST + eax], ebx
 
        mov     ebx, [NET_DRV_LIST + eax]
        mov     eax, [IP_LIST + eax]
        call    ARP_output_request              ; now send a gratuitous ARP
 
        call    NET_send_event
        xor     eax, eax
        ret
 
  .read_dns:
        mov     eax, [DNS_LIST + eax]
        ret
 
  .write_dns:
        mov     [DNS_LIST + eax], ecx
        call    NET_send_event
        xor     eax, eax
        ret
 
  .read_subnet:
        mov     eax, [SUBNET_LIST + eax]
        ret
 
  .write_subnet:
        mov     [SUBNET_LIST + eax], ecx
 
        ; pre-calculate the local broadcast address
        mov     ebx, [IP_LIST + eax]
        not     ecx
        or      ecx, ebx
        mov     [BROADCAST_LIST + eax], ecx
 
        call    NET_send_event
        xor     eax, eax
        ret
 
  .read_gateway:
        mov     eax, [GATEWAY_LIST + eax]
        ret
 
  .write_gateway:
        mov     [GATEWAY_LIST + eax], ecx
 
        call    NET_send_event
        xor     eax, eax
        ret
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
;>
;>
;>
;>
;>
;>

Rev 4423	Rev 5201
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2014. 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	;; IPv4.INC ;;	6	;; IPv4.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	;; Based on the work of [Johnny_B] and [smb] ;;	10	;; Based on the work of [Johnny_B] and [smb] ;;
11	;; ;;	11	;; ;;
12	;; Written by hidnplayr@kolibrios.org ;;	12	;; Written by hidnplayr@kolibrios.org ;;
13	;; ;;	13	;; ;;
14	;; GNU GENERAL PUBLIC LICENSE ;;	14	;; GNU GENERAL PUBLIC LICENSE ;;
15	;; Version 2, June 1991 ;;	15	;; Version 2, June 1991 ;;
16	;; ;;	16	;; ;;
17	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	17	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
18		18
19	$Revision: 3515 $	19	$Revision: 3515 $
20		20
21	IPv4_MAX_FRAGMENTS = 64	21	IPv4_MAX_FRAGMENTS = 64
22	IPv4_MAX_ROUTES = 64	22	IPv4_MAX_ROUTES = 64
23		23
24	IPv4_ROUTE_FLAG_UP = 1 shl 0	24	IPv4_ROUTE_FLAG_UP = 1 shl 0
25	IPv4_ROUTE_FLAG_GATEWAY = 1 shl 1	25	IPv4_ROUTE_FLAG_GATEWAY = 1 shl 1
26	IPv4_ROUTE_FLAG_HOST = 1 shl 2	26	IPv4_ROUTE_FLAG_HOST = 1 shl 2
27	IPv4_ROUTE_FLAG_D = 1 shl 3 ; Route was created by a redirect	27	IPv4_ROUTE_FLAG_D = 1 shl 3 ; Route was created by a redirect
28	IPv4_ROUTE_FLAG_M = 1 shl 4 ; Route was modified by a redirect	28	IPv4_ROUTE_FLAG_M = 1 shl 4 ; Route was modified by a redirect
29		29
30	struct IPv4_header	30	struct IPv4_header
31		31
32	VersionAndIHL db ? ; Version[0-3 bits] and IHL(header length)[4-7 bits]	32	VersionAndIHL db ? ; Version[0-3 bits] and IHL(header length)[4-7 bits]
33	TypeOfService db ? ; precedence [7-5] minimize delay [4], maximize throughput [3], maximize riliability [2] minimize momentary cost [1] and zero [0]	33	TypeOfService db ? ; precedence [7-5] minimize delay [4], maximize throughput [3], maximize riliability [2] minimize momentary cost [1] and zero [0]
34	TotalLength dw ?	34	TotalLength dw ?
35	Identification dw ?	35	Identification dw ?
36	FlagsAndFragmentOffset dw ? ; Flags[0-2] and FragmentOffset[3-15]	36	FlagsAndFragmentOffset dw ? ; Flags[0-2] and FragmentOffset[3-15]
37	TimeToLive db ? ;	37	TimeToLive db ? ;
38	Protocol db ?	38	Protocol db ?
39	HeaderChecksum dw ?	39	HeaderChecksum dw ?
40	SourceAddress dd ?	40	SourceAddress dd ?
41	DestinationAddress dd ?	41	DestinationAddress dd ?
42		42
43	ends	43	ends
44		44
45	struct IPv4_FRAGMENT_slot	45	struct IPv4_FRAGMENT_slot
46		46
47	ttl dw ? ; Time to live for this entry, 0 for empty slot's	47	ttl dw ? ; Time to live for this entry, 0 for empty slot's
48	id dw ? ; Identification field from IP header	48	id dw ? ; Identification field from IP header
49	SrcIP dd ? ; .. from IP header	49	SrcIP dd ? ; .. from IP header
50	DstIP dd ? ; .. from IP header	50	DstIP dd ? ; .. from IP header
51	ptr dd ? ; Pointer to first packet	51	ptr dd ? ; Pointer to first packet
52		52
53	ends	53	ends
54		54
55	struct IPv4_FRAGMENT_entry ; This structure will replace the ethernet header in fragmented ip packets	55	struct IPv4_FRAGMENT_entry ; This structure will replace the ethernet header in fragmented ip packets
56		56
57	PrevPtr dd ? ; Pointer to previous fragment entry (-1 for first packet)	57	PrevPtr dd ? ; Pointer to previous fragment entry (-1 for first packet)
58	NextPtr dd ? ; Pointer to next fragment entry (-1 for last packet)	58	NextPtr dd ? ; Pointer to next fragment entry (-1 for last packet)
59	Owner dd ? ; Pointer to structure of driver	59	Owner dd ? ; Pointer to structure of driver
60	rb 2 ; to match ethernet header size ;;; FIXME	60	rb 2 ; to match ethernet header size ;;; FIXME
61	; Ip header begins here (we will need the IP header to re-construct the complete packet)	61	; Ip header begins here (we will need the IP header to re-construct the complete packet)
62	ends	62	ends
63		63
64	struct IPv4_ROUTE	64	struct IPv4_ROUTE
65		65
66	Destination dd ?	66	Destination dd ?
67	Gateway dd ?	67	Gateway dd ?
68	Flags dd ?	68	Flags dd ?
69	Use dd ?	69	Use dd ?
70	Interface dd ?	70	Interface dd ?
71		71
72	ends	72	ends
73		73
74		74
75	uglobal	75	uglobal
76	align 4	76	align 4
77		77
78	IP_LIST rd NET_DEVICES_MAX	78	IP_LIST rd NET_DEVICES_MAX
79	SUBNET_LIST rd NET_DEVICES_MAX	79	SUBNET_LIST rd NET_DEVICES_MAX
80	DNS_LIST rd NET_DEVICES_MAX	80	DNS_LIST rd NET_DEVICES_MAX
81	GATEWAY_LIST rd NET_DEVICES_MAX	81	GATEWAY_LIST rd NET_DEVICES_MAX
82	BROADCAST_LIST rd NET_DEVICES_MAX	82	BROADCAST_LIST rd NET_DEVICES_MAX
83		83
84	IPv4_packets_tx rd NET_DEVICES_MAX	84	IPv4_packets_tx rd NET_DEVICES_MAX
85	IPv4_packets_rx rd NET_DEVICES_MAX	85	IPv4_packets_rx rd NET_DEVICES_MAX
86	IPv4_packets_dumped rd NET_DEVICES_MAX	86	IPv4_packets_dumped rd NET_DEVICES_MAX
87		87
88	IPv4_FRAGMENT_LIST rb IPv4_MAX_FRAGMENTS * sizeof.IPv4_FRAGMENT_slot	88	IPv4_FRAGMENT_LIST rb IPv4_MAX_FRAGMENTS * sizeof.IPv4_FRAGMENT_slot
89		89
90	IPv4_ROUTES rd IPv4_MAX_ROUTES * sizeof.IPv4_ROUTE	90	IPv4_ROUTES rd IPv4_MAX_ROUTES * sizeof.IPv4_ROUTE
91		91
92	endg	92	endg
93		93
94		94
95	;-----------------------------------------------------------------	95	;-----------------------------------------------------------------
96	;	96	;
97	; IPv4_init	97	; IPv4_init
98	;	98	;
99	; This function resets all IP variables	99	; This function resets all IP variables
100	;	100	;
101	;-----------------------------------------------------------------	101	;-----------------------------------------------------------------
102	macro IPv4_init {	102	macro IPv4_init {
103		103
104	xor eax, eax	104	xor eax, eax
105	mov edi, IP_LIST	105	mov edi, IP_LIST
106	mov ecx, 7NET_DEVICES_MAX + (sizeof.IPv4_FRAGMENT_slotIPv4_MAX_FRAGMENTS)/4	106	mov ecx, 7NET_DEVICES_MAX + (sizeof.IPv4_FRAGMENT_slotIPv4_MAX_FRAGMENTS)/4
107	rep stosd	107	rep stosd
108		108
109	}	109	}
110		110
111		111
112	;-----------------------------------------------------------------	112	;-----------------------------------------------------------------
113	;	113	;
114	; Decrease TimeToLive of all fragment slots	114	; Decrease TimeToLive of all fragment slots
115	;	115	;
116	;-----------------------------------------------------------------	116	;-----------------------------------------------------------------
117	macro IPv4_decrease_fragment_ttls {	117	macro IPv4_decrease_fragment_ttls {
118		118
119	local .loop, .next	119	local .loop, .next
120		120
121	mov esi, IPv4_FRAGMENT_LIST	121	mov esi, IPv4_FRAGMENT_LIST
122	mov ecx, IPv4_MAX_FRAGMENTS	122	mov ecx, IPv4_MAX_FRAGMENTS
123	.loop:	123	.loop:
124	cmp [esi + IPv4_FRAGMENT_slot.ttl], 0	124	cmp [esi + IPv4_FRAGMENT_slot.ttl], 0
125	je .next	125	je .next
126	dec [esi + IPv4_FRAGMENT_slot.ttl]	126	dec [esi + IPv4_FRAGMENT_slot.ttl]
127	jz .died	127	jz .died
128	.next:	128	.next:
129	add esi, sizeof.IPv4_FRAGMENT_slot	129	add esi, sizeof.IPv4_FRAGMENT_slot
130	dec ecx	130	dec ecx
131	jnz .loop	131	jnz .loop
132	jmp .done	132	jmp .done
133		133
134	.died:	134	.died:
135	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4 Fragment slot timed-out!\n"	135	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4 Fragment slot timed-out!\n"
136	;;; TODO: clear all entry's of timed-out slot	136	;;; TODO: clear all entry's of timed-out slot
137	jmp .next	137	jmp .next
138		138
139	.done:	139	.done:
140	}	140	}
141		141
142		142
143		143
144	macro IPv4_checksum ptr {	144	macro IPv4_checksum ptr {
145		145
146	; This is the fast procedure to create or check an IP header without options	146	; This is the fast procedure to create or check an IP header without options
147	; To create a new checksum, the checksum field must be set to 0 before computation	147	; To create a new checksum, the checksum field must be set to 0 before computation
148	; To check an existing checksum, leave the checksum as is, and it will be 0 after this procedure, if it was correct	148	; To check an existing checksum, leave the checksum as is, and it will be 0 after this procedure, if it was correct
149		149
150	push ebx	150	push ebx
151	xor ebx, ebx	151	xor ebx, ebx
152	add bl, [ptr+1]	152	add bl, [ptr+1]
153	adc bh, [ptr+0]	153	adc bh, [ptr+0]
154		154
155	adc bl, [ptr+3]	155	adc bl, [ptr+3]
156	adc bh, [ptr+2]	156	adc bh, [ptr+2]
157		157
158	adc bl, [ptr+5]	158	adc bl, [ptr+5]
159	adc bh, [ptr+4]	159	adc bh, [ptr+4]
160		160
161	adc bl, [ptr+7]	161	adc bl, [ptr+7]
162	adc bh, [ptr+6]	162	adc bh, [ptr+6]
163		163
164	adc bl, [ptr+9]	164	adc bl, [ptr+9]
165	adc bh, [ptr+8]	165	adc bh, [ptr+8]
166		166
167	; we skip 11th and 12th byte, they are the checksum bytes and should be 0 for re-calculation	167	; we skip 11th and 12th byte, they are the checksum bytes and should be 0 for re-calculation
168		168
169	adc bl, [ptr+13]	169	adc bl, [ptr+13]
170	adc bh, [ptr+12]	170	adc bh, [ptr+12]
171		171
172	adc bl, [ptr+15]	172	adc bl, [ptr+15]
173	adc bh, [ptr+14]	173	adc bh, [ptr+14]
174		174
175	adc bl, [ptr+17]	175	adc bl, [ptr+17]
176	adc bh, [ptr+16]	176	adc bh, [ptr+16]
177		177
178	adc bl, [ptr+19]	178	adc bl, [ptr+19]
179	adc bh, [ptr+18]	179	adc bh, [ptr+18]
180		180
181	adc ebx, 0	181	adc ebx, 0
182		182
183	push ecx	183	push ecx
184	mov ecx, ebx	184	mov ecx, ebx
185	shr ecx, 16	185	shr ecx, 16
186	and ebx, 0xffff	186	and ebx, 0xffff
187	add ebx, ecx	187	add ebx, ecx
188		188
189	mov ecx, ebx	189	mov ecx, ebx
190	shr ecx, 16	190	shr ecx, 16
191	add ebx, ecx	191	add ebx, ecx
192		192
193	not bx	193	not bx
194	jnz .not_zero	194	jnz .not_zero
195	dec bx	195	dec bx
196	.not_zero:	196	.not_zero:
197	xchg bl, bh	197	xchg bl, bh
198	pop ecx	198	pop ecx
199		199
200	neg word [ptr+10] ; zero will stay zero so we just get the checksum	200	neg word [ptr+10] ; zero will stay zero so we just get the checksum
201	add word [ptr+10], bx ; , else we will get (new checksum - old checksum) in the end, wich should be 0 :)	201	add word [ptr+10], bx ; , else we will get (new checksum - old checksum) in the end, wich should be 0 :)
202	pop ebx	202	pop ebx
203		203
204	}	204	}
205		205
206		206
207		207
208	;-----------------------------------------------------------------	208	;-----------------------------------------------------------------
209	;	209	;
210	; IPv4_input:	210	; IPv4_input:
211	;	211	;
212	; Will check if IPv4 Packet isnt damaged	212	; Will check if IPv4 Packet isnt damaged
213	; and call appropriate handler. (TCP/UDP/ICMP/..)	213	; and call appropriate handler. (TCP/UDP/ICMP/..)
214	;	214	;
215	; It will also re-construct fragmented packets	215	; It will also re-construct fragmented packets
216	;	216	;
217	; IN: Pointer to buffer in [esp]	217	; IN: Pointer to buffer in [esp]
218	; size of buffer in [esp+4]	218	; size of buffer in [esp+4]
219	; pointer to device struct in ebx	219	; pointer to device struct in ebx
220	; pointer to IPv4 header in edx	220	; pointer to IPv4 header in edx
221	; size of IPv4 packet in ecx	221	; size of IPv4 packet in ecx
222	; OUT: /	222	; OUT: /
223	;	223	;
224	;-----------------------------------------------------------------	224	;-----------------------------------------------------------------
225	align 4	225	align 4
226	IPv4_input: ; TODO: add IPv4 raw sockets support	226	IPv4_input: ; TODO: add IPv4 raw sockets support
227		227
228	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input, packet from: %u.%u.%u.%u ",\	228	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input, packet from: %u.%u.%u.%u ",\
229	[edx + IPv4_header.SourceAddress + 0]:1,[edx + IPv4_header.SourceAddress + 1]:1,\	229	[edx + IPv4_header.SourceAddress + 0]:1,[edx + IPv4_header.SourceAddress + 1]:1,\
230	[edx + IPv4_header.SourceAddress + 2]:1,[edx + IPv4_header.SourceAddress + 3]:1	230	[edx + IPv4_header.SourceAddress + 2]:1,[edx + IPv4_header.SourceAddress + 3]:1
231	DEBUGF DEBUG_NETWORK_VERBOSE, "to: %u.%u.%u.%u\n",\	231	DEBUGF DEBUG_NETWORK_VERBOSE, "to: %u.%u.%u.%u\n",\
232	[edx + IPv4_header.DestinationAddress + 0]:1,[edx + IPv4_header.DestinationAddress + 1]:1,\	232	[edx + IPv4_header.DestinationAddress + 0]:1,[edx + IPv4_header.DestinationAddress + 1]:1,\
233	[edx + IPv4_header.DestinationAddress + 2]:1,[edx + IPv4_header.DestinationAddress + 3]:1	233	[edx + IPv4_header.DestinationAddress + 2]:1,[edx + IPv4_header.DestinationAddress + 3]:1
234		234
235	;-------------------------------	235	;-------------------------------
236	; re-calculate the checksum	236	; re-calculate the checksum
237		237
238	IPv4_checksum edx	238	IPv4_checksum edx
239	jnz .dump ; if checksum isn't valid then dump packet	239	jnz .dump ; if checksum isn't valid then dump packet
240		240
241	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Checksum ok\n"	241	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Checksum ok\n"
242		242
243	;-----------------------------------	243	;-----------------------------------
244	; Check if destination IP is correct	244	; Check if destination IP is correct
245		245
246	call NET_ptr_to_num4	246	call NET_ptr_to_num4
247		247
248	; check if it matches local ip (Using RFC1122 strong end system model)	248	; check if it matches local ip (Using RFC1122 strong end system model)
249		249
250	mov eax, [edx + IPv4_header.DestinationAddress]	250	mov eax, [edx + IPv4_header.DestinationAddress]
251	cmp eax, [IP_LIST + edi]	251	cmp eax, [IP_LIST + edi]
252	je .ip_ok	252	je .ip_ok
253		253
254	; check for broadcast (IP or (not SUBNET))	254	; check for broadcast (IP or (not SUBNET))
255		255
256	cmp eax, [BROADCAST_LIST + edi]	256	cmp eax, [BROADCAST_LIST + edi]
257	je .ip_ok	257	je .ip_ok
258		258
259	; or a special broadcast (255.255.255.255)	259	; or a special broadcast (255.255.255.255)
260		260
261	cmp eax, 0xffffffff	261	cmp eax, 0xffffffff
262	je .ip_ok	262	je .ip_ok
263		263
264	; maybe it's a multicast (224.0.0.0/4)	264	; maybe it's a multicast (224.0.0.0/4)
265		265
266	and eax, 0x0fffffff	266	and eax, 0x0fffffff
267	cmp eax, 224	267	cmp eax, 224
268	je .ip_ok	268	je .ip_ok
269		269
270	; or a loopback address (127.0.0.0/8)	-
271		270	; maybe we just dont have an IP yet and should accept everything on the IP level
272	and eax, 0x00ffffff	271
273	cmp eax, 127	272	cmp [IP_LIST + edi], 0
274	je .ip_ok	273	je .ip_ok
275		274
276	; or it's just not meant for us.. :(	275	; or it's just not meant for us.. :(
277		276
278	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Destination address does not match!\n"	277	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Destination address does not match!\n"
279	jmp .dump	278	jmp .dump
280		279
281	;------------------------	280	;------------------------
282	; Now we can update stats	281	; Now we can update stats
283		282
284	.ip_ok:	283	.ip_ok:
285	inc [IPv4_packets_rx + edi]	284	inc [IPv4_packets_rx + edi]
286		285
287	;----------------------------------	286	;----------------------------------
288	; Check if the packet is fragmented	287	; Check if the packet is fragmented
289		288
290	test [edx + IPv4_header.FlagsAndFragmentOffset], 1 shl 5 ; Is 'more fragments' flag set ?	289	test [edx + IPv4_header.FlagsAndFragmentOffset], 1 shl 5 ; Is 'more fragments' flag set ?
291	jnz .has_fragments ; If so, we definately have a fragmented packet	290	jnz .has_fragments ; If so, we definately have a fragmented packet
292		291
293	test [edx + IPv4_header.FlagsAndFragmentOffset], 0xff1f ; If flag is not set, but there is a fragment offset, the packet is last in series of fragmented packets	292	test [edx + IPv4_header.FlagsAndFragmentOffset], 0xff1f ; If flag is not set, but there is a fragment offset, the packet is last in series of fragmented packets
294	jnz .is_last_fragment	293	jnz .is_last_fragment
295		294
296	;-------------------------------------------------------------------	295	;-------------------------------------------------------------------
297	; No, it's just a regular IP packet, pass it to the higher protocols	296	; No, it's just a regular IP packet, pass it to the higher protocols
298		297
299	.handle_it: ; We reach here if packet hasnt been fragmented, or when it already has been re-constructed	298	.handle_it: ; We reach here if packet hasnt been fragmented, or when it already has been re-constructed
300		299
301	movzx esi, [edx + IPv4_header.VersionAndIHL] ; Calculate Header length by using IHL field	300	movzx esi, [edx + IPv4_header.VersionAndIHL] ; Calculate Header length by using IHL field
302	and esi, 0x0000000f ;	301	and esi, 0x0000000f ;
303	shl esi, 2 ;	302	shl esi, 2 ;
304		303
305	movzx ecx, [edx + IPv4_header.TotalLength] ; Calculate length of encapsulated Packet	304	movzx ecx, [edx + IPv4_header.TotalLength] ; Calculate length of encapsulated Packet
306	xchg cl, ch ;	305	xchg cl, ch ;
307	sub ecx, esi ;	306	sub ecx, esi ;
308		307
309	lea edi, [edx + IPv4_header.SourceAddress] ; make edi ptr to source and dest IPv4 address	308	lea edi, [edx + IPv4_header.SourceAddress] ; make edi ptr to source and dest IPv4 address
310	mov al, [edx + IPv4_header.Protocol]	309	mov al, [edx + IPv4_header.Protocol]
311	add esi, edx ; make esi ptr to data	310	add esi, edx ; make esi ptr to data
312		311
313	cmp al, IP_PROTO_TCP	312	cmp al, IP_PROTO_TCP
314	je TCP_input	313	je TCP_input
315		314
316	cmp al, IP_PROTO_UDP	315	cmp al, IP_PROTO_UDP
317	je UDP_input	316	je UDP_input
318		317
319	cmp al, IP_PROTO_ICMP	318	cmp al, IP_PROTO_ICMP
320	je ICMP_input	319	je ICMP_input
321		320
322	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: unknown protocol %u\n", al	321	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: unknown protocol %u\n", al
323		322
324	.dump:	323	.dump:
325	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: dumping\n"	324	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: dumping\n"
326	inc [IPv4_packets_dumped] ; FIXME: use correct interface	325	inc [IPv4_packets_dumped] ; FIXME: use correct interface
327	call NET_packet_free	326	call NET_packet_free
328	add esp, 4 ; pop (balance stack)	327	add esp, 4 ; pop (balance stack)
329	ret	328	ret
330		329
331		330
332	;---------------------------	331	;---------------------------
333	; Fragmented packet handler	332	; Fragmented packet handler
334		333
335		334
336	.has_fragments:	335	.has_fragments:
337	movzx eax, [edx + IPv4_header.FlagsAndFragmentOffset]	336	movzx eax, [edx + IPv4_header.FlagsAndFragmentOffset]
338	xchg al, ah	337	xchg al, ah
339	shl ax, 3	338	shl ax, 3
340		339
341	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: fragmented packet offset=%u id=%x ptr=0x%x\n", ax, [edx + IPv4_header.Identification]:4, edx	340	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: fragmented packet offset=%u id=%x ptr=0x%x\n", ax, [edx + IPv4_header.Identification]:4, edx
342		341
343	test ax, ax ; Is this the first packet of the fragment?	342	test ax, ax ; Is this the first packet of the fragment?
344	jz .is_first_fragment	343	jz .is_first_fragment
345		344
346		345
347	;-------------------------------------------------------	346	;-------------------------------------------------------
348	; We have a fragmented IP packet, but it's not the first	347	; We have a fragmented IP packet, but it's not the first
349		348
350	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Middle fragment packet received!\n"	349	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Middle fragment packet received!\n"
351		350
352	call IPv4_find_fragment_slot	351	call IPv4_find_fragment_slot
353	cmp esi, -1	352	cmp esi, -1
354	je .dump	353	je .dump
355		354
356	mov [esi + IPv4_FRAGMENT_slot.ttl], 15 ; Reset the ttl	355	mov [esi + IPv4_FRAGMENT_slot.ttl], 15 ; Reset the ttl
357	mov esi, [esi + IPv4_FRAGMENT_slot.ptr]	356	mov esi, [esi + IPv4_FRAGMENT_slot.ptr]
358	or edi, -1	357	or edi, -1
359	.find_last_entry: ; The following routine will try to find the last entry	358	.find_last_entry: ; The following routine will try to find the last entry
360	cmp edi, [esi + IPv4_FRAGMENT_entry.PrevPtr]	359	cmp edi, [esi + IPv4_FRAGMENT_entry.PrevPtr]
361	jne .destroy_slot ; Damn, something screwed up, remove the whole slot (and free buffers too if possible!)	360	jne .destroy_slot ; Damn, something screwed up, remove the whole slot (and free buffers too if possible!)
362	mov edi, esi	361	mov edi, esi
363	mov esi, [esi + IPv4_FRAGMENT_entry.NextPtr]	362	mov esi, [esi + IPv4_FRAGMENT_entry.NextPtr]
364	cmp esi, -1	363	cmp esi, -1
365	jne .find_last_entry	364	jne .find_last_entry
366	; We found the last entry (pointer is now in edi)	365	; We found the last entry (pointer is now in edi)
367	; We are going to overwrite the ethernet header in received packet with a FRAGMENT_entry structure	366	; We are going to overwrite the ethernet header in received packet with a FRAGMENT_entry structure
368		367
369	pop eax ; pointer to packet	368	pop eax ; pointer to packet
370	mov [edi + IPv4_FRAGMENT_entry.NextPtr], eax ; update pointer of previous entry to the new entry	369	mov [edi + IPv4_FRAGMENT_entry.NextPtr], eax ; update pointer of previous entry to the new entry
371	mov [eax + IPv4_FRAGMENT_entry.NextPtr], -1	370	mov [eax + IPv4_FRAGMENT_entry.NextPtr], -1
372	mov [eax + IPv4_FRAGMENT_entry.PrevPtr], edi	371	mov [eax + IPv4_FRAGMENT_entry.PrevPtr], edi
373	mov [eax + IPv4_FRAGMENT_entry.Owner], ebx	372	mov [eax + IPv4_FRAGMENT_entry.Owner], ebx
374		373
375	add esp, 4	374	add esp, 4
376	ret	375	ret
377		376
378		377
379	;------------------------------------	378	;------------------------------------
380	; We have received the first fragment	379	; We have received the first fragment
381		380
382	.is_first_fragment:	381	.is_first_fragment:
383	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: First fragment packet received!\n"	382	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: First fragment packet received!\n"
384	; try to locate a free slot..	383	; try to locate a free slot..
385	mov ecx, IPv4_MAX_FRAGMENTS	384	mov ecx, IPv4_MAX_FRAGMENTS
386	mov esi, IPv4_FRAGMENT_LIST	385	mov esi, IPv4_FRAGMENT_LIST
387	.find_free_slot:	386	.find_free_slot:
388	cmp word [esi + IPv4_FRAGMENT_slot.ttl], 0	387	cmp word [esi + IPv4_FRAGMENT_slot.ttl], 0
389	je .found_free_slot	388	je .found_free_slot
390	add esi, sizeof.IPv4_FRAGMENT_slot	389	add esi, sizeof.IPv4_FRAGMENT_slot
391	loop .find_free_slot	390	loop .find_free_slot
392	jmp .dump ; If no free slot was found, dump the packet	391	jmp .dump ; If no free slot was found, dump the packet
393		392
394	.found_free_slot: ; We found a free slot, let's fill in the FRAGMENT_slot structure	393	.found_free_slot: ; We found a free slot, let's fill in the FRAGMENT_slot structure
395	mov [esi + IPv4_FRAGMENT_slot.ttl], 15 ; RFC recommends 15 secs as ttl	394	mov [esi + IPv4_FRAGMENT_slot.ttl], 15 ; RFC recommends 15 secs as ttl
396	mov ax, [edx + IPv4_header.Identification]	395	mov ax, [edx + IPv4_header.Identification]
397	mov [esi + IPv4_FRAGMENT_slot.id], ax	396	mov [esi + IPv4_FRAGMENT_slot.id], ax
398	mov eax, [edx + IPv4_header.SourceAddress]	397	mov eax, [edx + IPv4_header.SourceAddress]
399	mov [esi + IPv4_FRAGMENT_slot.SrcIP], eax	398	mov [esi + IPv4_FRAGMENT_slot.SrcIP], eax
400	mov eax, [edx + IPv4_header.DestinationAddress]	399	mov eax, [edx + IPv4_header.DestinationAddress]
401	mov [esi + IPv4_FRAGMENT_slot.DstIP], eax	400	mov [esi + IPv4_FRAGMENT_slot.DstIP], eax
402	pop eax	401	pop eax
403	mov [esi + IPv4_FRAGMENT_slot.ptr], eax	402	mov [esi + IPv4_FRAGMENT_slot.ptr], eax
404	; Now, replace ethernet header in original buffer with a FRAGMENT_entry structure	403	; Now, replace ethernet header in original buffer with a FRAGMENT_entry structure
405	mov [eax + IPv4_FRAGMENT_entry.NextPtr], -1	404	mov [eax + IPv4_FRAGMENT_entry.NextPtr], -1
406	mov [eax + IPv4_FRAGMENT_entry.PrevPtr], -1	405	mov [eax + IPv4_FRAGMENT_entry.PrevPtr], -1
407	mov [eax + IPv4_FRAGMENT_entry.Owner], ebx	406	mov [eax + IPv4_FRAGMENT_entry.Owner], ebx
408		407
409	add esp, 4 ; balance stack and exit	408	add esp, 4 ; balance stack and exit
410	ret	409	ret
411		410
412		411
413	;-----------------------------------	412	;-----------------------------------
414	; We have received the last fragment	413	; We have received the last fragment
415		414
416	.is_last_fragment:	415	.is_last_fragment:
417	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Last fragment packet received!\n"	416	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Last fragment packet received!\n"
418		417
419	call IPv4_find_fragment_slot	418	call IPv4_find_fragment_slot
420	cmp esi, -1	419	cmp esi, -1
421	je .dump	420	je .dump
422		421
423	mov esi, [esi + IPv4_FRAGMENT_slot.ptr] ; We found the first entry, let's calculate total size of the packet in eax, so we can allocate a buffer	422	mov esi, [esi + IPv4_FRAGMENT_slot.ptr] ; We found the first entry, let's calculate total size of the packet in eax, so we can allocate a buffer
424	push esi	423	push esi
425	xor eax, eax	424	xor eax, eax
426	or edi, -1	425	or edi, -1
427		426
428	.count_bytes:	427	.count_bytes:
429	cmp [esi + IPv4_FRAGMENT_entry.PrevPtr], edi	428	cmp [esi + IPv4_FRAGMENT_entry.PrevPtr], edi
430	jne .destroy_slot_pop ; Damn, something screwed up, remove the whole slot (and free buffers too if possible!)	429	jne .destroy_slot_pop ; Damn, something screwed up, remove the whole slot (and free buffers too if possible!)
431	mov cx, [esi + sizeof.IPv4_FRAGMENT_entry + IPv4_header.TotalLength] ; Add total length	430	mov cx, [esi + sizeof.IPv4_FRAGMENT_entry + IPv4_header.TotalLength] ; Add total length
432	xchg cl, ch	431	xchg cl, ch
433	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Packet size=%u\n", cx	432	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Packet size=%u\n", cx
434	add ax, cx	433	add ax, cx
435	movzx cx, [esi + sizeof.IPv4_FRAGMENT_entry + IPv4_header.VersionAndIHL] ; Sub Header length	434	movzx cx, [esi + sizeof.IPv4_FRAGMENT_entry + IPv4_header.VersionAndIHL] ; Sub Header length
436	and cx, 0x000F	435	and cx, 0x000F
437	shl cx, 2	436	shl cx, 2
438	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Header size=%u\n", cx	437	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Header size=%u\n", cx
439	sub ax, cx	438	sub ax, cx
440	mov edi, esi	439	mov edi, esi
441	mov esi, [esi + IPv4_FRAGMENT_entry.NextPtr]	440	mov esi, [esi + IPv4_FRAGMENT_entry.NextPtr]
442	cmp esi, -1	441	cmp esi, -1
443	jne .count_bytes	442	jne .count_bytes
444		443
445	mov esi, [esp+4]	444	mov esi, [esp+4]
446	mov [edi + IPv4_FRAGMENT_entry.NextPtr], esi ; Add this packet to the chain, this simplifies the following code	445	mov [edi + IPv4_FRAGMENT_entry.NextPtr], esi ; Add this packet to the chain, this simplifies the following code
447	mov [esi + IPv4_FRAGMENT_entry.NextPtr], -1	446	mov [esi + IPv4_FRAGMENT_entry.NextPtr], -1
448	mov [esi + IPv4_FRAGMENT_entry.PrevPtr], edi	447	mov [esi + IPv4_FRAGMENT_entry.PrevPtr], edi
449	mov [esi + IPv4_FRAGMENT_entry.Owner], ebx	448	mov [esi + IPv4_FRAGMENT_entry.Owner], ebx
450		449
451	mov cx, [edx + IPv4_header.TotalLength] ; Note: This time we dont substract Header length	450	mov cx, [edx + IPv4_header.TotalLength] ; Note: This time we dont substract Header length
452	xchg cl, ch	451	xchg cl, ch
453	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Packet size=%u\n", cx	452	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Packet size=%u\n", cx
454	add ax, cx	453	add ax, cx
455	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Total Received data size=%u\n", eax	454	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Total Received data size=%u\n", eax
456		455
457	push eax	456	push eax
458	mov ax, [edx + IPv4_header.FlagsAndFragmentOffset]	457	mov ax, [edx + IPv4_header.FlagsAndFragmentOffset]
459	xchg al, ah	458	xchg al, ah
460	shl ax, 3	459	shl ax, 3
461	add cx, ax	460	add cx, ax
462	pop eax	461	pop eax
463	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Total Fragment size=%u\n", ecx	462	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Total Fragment size=%u\n", ecx
464		463
465	cmp ax, cx	464	cmp ax, cx
466	jne .destroy_slot_pop	465	jne .destroy_slot_pop
467		466
468	push eax	467	push eax
469	push eax	468	push eax
470	call kernel_alloc	469	call kernel_alloc
471	test eax, eax	470	test eax, eax
472	je .destroy_slot_pop ; If we dont have enough space to allocate the buffer, discard all packets in slot	471	je .destroy_slot_pop ; If we dont have enough space to allocate the buffer, discard all packets in slot
473	mov edx, [esp+4] ; Get pointer to first fragment entry back in edx	472	mov edx, [esp+4] ; Get pointer to first fragment entry back in edx
474		473
475	.rebuild_packet_loop:	474	.rebuild_packet_loop:
476	movzx ecx, [edx + sizeof.IPv4_FRAGMENT_entry + IPv4_header.FlagsAndFragmentOffset] ; Calculate the fragment offset	475	movzx ecx, [edx + sizeof.IPv4_FRAGMENT_entry + IPv4_header.FlagsAndFragmentOffset] ; Calculate the fragment offset
477	xchg cl, ch ; intel byte order	476	xchg cl, ch ; intel byte order
478	shl cx, 3 ; multiply by 8 and clear first 3 bits	477	shl cx, 3 ; multiply by 8 and clear first 3 bits
479	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Fragment offset=%u\n", cx	478	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Fragment offset=%u\n", cx
480		479
481	lea edi, [eax + ecx] ; Notice that edi will be equal to eax for first fragment	480	lea edi, [eax + ecx] ; Notice that edi will be equal to eax for first fragment
482	movzx ebx, [edx + sizeof.IPv4_FRAGMENT_entry + IPv4_header.VersionAndIHL] ; Find header size (in ebx) of fragment	481	movzx ebx, [edx + sizeof.IPv4_FRAGMENT_entry + IPv4_header.VersionAndIHL] ; Find header size (in ebx) of fragment
483	and bx, 0x000F ;	482	and bx, 0x000F ;
484	shl bx, 2 ;	483	shl bx, 2 ;
485		484
486	lea esi, [edx + sizeof.IPv4_FRAGMENT_entry] ; Set esi to the correct begin of fragment	485	lea esi, [edx + sizeof.IPv4_FRAGMENT_entry] ; Set esi to the correct begin of fragment
487	movzx ecx, [edx + sizeof.IPv4_FRAGMENT_entry + IPv4_header.TotalLength] ; Calculate total length of fragment	486	movzx ecx, [edx + sizeof.IPv4_FRAGMENT_entry + IPv4_header.TotalLength] ; Calculate total length of fragment
488	xchg cl, ch ; intel byte order	487	xchg cl, ch ; intel byte order
489		488
490	cmp edi, eax ; Is this packet the first fragment ?	489	cmp edi, eax ; Is this packet the first fragment ?
491	je .first_fragment	490	je .first_fragment
492	sub cx, bx ; If not, dont copy the header	491	sub cx, bx ; If not, dont copy the header
493	add esi, ebx ;	492	add esi, ebx ;
494	.first_fragment:	493	.first_fragment:
495		494
496		495
497	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Copying %u bytes from 0x%x to 0x%x\n", ecx, esi, edi	496	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Copying %u bytes from 0x%x to 0x%x\n", ecx, esi, edi
498	push cx ; First copy dword-wise, then byte-wise	497	push cx ; First copy dword-wise, then byte-wise
499	shr cx, 2 ;	498	shr cx, 2 ;
500	rep movsd ;	499	rep movsd ;

Subversion Repositories Kolibri OS

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