WebSVN – Kolibri OS – Diff – /kernel/trunk/network/IPv4.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2015. 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: 5584 $
 
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_BUFF_free
        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
 
        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
 
        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_BUFF_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
;       ebx = device ptr (or 0 to let IP layer decide)
;       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], eax                        ; set 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
;     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_BUFF_free
        ret
 
 
 
;---------------------------------------------------------------------------
;
; IPv4_route
;
; IN:   eax = Destination IP
;       ebx = outgoing device / 0
;       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
 
        test    ebx, ebx
        jnz     .got_device
 
        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
 
  .got_device:
; Validate device ptr and convert to device number
        call    NET_ptr_to_num4
        cmp     edi, -1
        je      .fail
 
        mov     edx, [IP_LIST + edi]            ; Source IP
 
; Check if we should route to gateway or not
        mov     ebx, [IP_LIST + edi]
        and     ebx, [SUBNET_LIST + edi]
        mov     ecx, eax
        and     ecx, [SUBNET_LIST + edi]
        je      @f
        mov     eax, [GATEWAY_LIST + edi]
  @@:
        ret
 
  .fail:
        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 5522	Rev 5584
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2015. 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	;; 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: 5522 $	19	$Revision: 5584 $
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	; maybe we just dont have an IP yet and should accept everything on the IP level	270	; maybe we just dont have an IP yet and should accept everything on the IP level
271		271
272	cmp [IP_LIST + edi], 0	272	cmp [IP_LIST + edi], 0
273	je .ip_ok	273	je .ip_ok
274		274
275	; or it's just not meant for us.. :(	275	; or it's just not meant for us.. :(
276		276
277	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"
278	jmp .dump	278	jmp .dump
279		279
280	;------------------------	280	;------------------------
281	; Now we can update stats	281	; Now we can update stats
282		282
283	.ip_ok:	283	.ip_ok:
284	inc [IPv4_packets_rx + edi]	284	inc [IPv4_packets_rx + edi]
285		285
286	;----------------------------------	286	;----------------------------------
287	; Check if the packet is fragmented	287	; Check if the packet is fragmented
288		288
289	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 ?
290	jnz .has_fragments ; If so, we definately have a fragmented packet	290	jnz .has_fragments ; If so, we definately have a fragmented packet
291		291
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	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
293	jnz .is_last_fragment	293	jnz .is_last_fragment
294		294
295	;-------------------------------------------------------------------	295	;-------------------------------------------------------------------
296	; 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
297		297
298	.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
299		299
300	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
301	and esi, 0x0000000f ;	301	and esi, 0x0000000f ;
302	shl esi, 2 ;	302	shl esi, 2 ;
303		303
304	movzx ecx, [edx + IPv4_header.TotalLength] ; Calculate length of encapsulated Packet	304	movzx ecx, [edx + IPv4_header.TotalLength] ; Calculate length of encapsulated Packet
305	xchg cl, ch ;	305	xchg cl, ch ;
306	sub ecx, esi ;	306	sub ecx, esi ;
307		307
308	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
309	mov al, [edx + IPv4_header.Protocol]	309	mov al, [edx + IPv4_header.Protocol]
310	add esi, edx ; make esi ptr to data	310	add esi, edx ; make esi ptr to data
311		311
312	cmp al, IP_PROTO_TCP	312	cmp al, IP_PROTO_TCP
313	je TCP_input	313	je TCP_input
314		314
315	cmp al, IP_PROTO_UDP	315	cmp al, IP_PROTO_UDP
316	je UDP_input	316	je UDP_input
317		317
318	cmp al, IP_PROTO_ICMP	318	cmp al, IP_PROTO_ICMP
319	je ICMP_input	319	je ICMP_input
320		320
321	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: unknown protocol %u\n", al	321	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: unknown protocol %u\n", al
322		322
323	.dump:	323	.dump:
324	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: dumping\n"	324	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: dumping\n"
325	inc [IPv4_packets_dumped] ; FIXME: use correct interface	325	inc [IPv4_packets_dumped] ; FIXME: use correct interface
326	call NET_BUFF_free	326	call NET_BUFF_free
327	ret	327	ret
328		328
329		329
330	;---------------------------	330	;---------------------------
331	; Fragmented packet handler	331	; Fragmented packet handler
332		332
333		333
334	.has_fragments:	334	.has_fragments:
335	movzx eax, [edx + IPv4_header.FlagsAndFragmentOffset]	335	movzx eax, [edx + IPv4_header.FlagsAndFragmentOffset]
336	xchg al, ah	336	xchg al, ah
337	shl ax, 3	337	shl ax, 3
338		338
339	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: fragmented packet offset=%u id=%x ptr=0x%x\n", ax, [edx + IPv4_header.Identification]:4, edx	339	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: fragmented packet offset=%u id=%x ptr=0x%x\n", ax, [edx + IPv4_header.Identification]:4, edx
340		340
341	test ax, ax ; Is this the first packet of the fragment?	341	test ax, ax ; Is this the first packet of the fragment?
342	jz .is_first_fragment	342	jz .is_first_fragment
343		343
344		344
345	;-------------------------------------------------------	345	;-------------------------------------------------------
346	; We have a fragmented IP packet, but it's not the first	346	; We have a fragmented IP packet, but it's not the first
347		347
348	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Middle fragment packet received!\n"	348	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Middle fragment packet received!\n"
349		349
350	call IPv4_find_fragment_slot	350	call IPv4_find_fragment_slot
351	cmp esi, -1	351	cmp esi, -1
352	je .dump	352	je .dump
353		353
354	mov [esi + IPv4_FRAGMENT_slot.ttl], 15 ; Reset the ttl	354	mov [esi + IPv4_FRAGMENT_slot.ttl], 15 ; Reset the ttl
355	mov esi, [esi + IPv4_FRAGMENT_slot.ptr]	355	mov esi, [esi + IPv4_FRAGMENT_slot.ptr]
356	or edi, -1	356	or edi, -1
357	.find_last_entry: ; The following routine will try to find the last entry	357	.find_last_entry: ; The following routine will try to find the last entry
358	cmp edi, [esi + IPv4_FRAGMENT_entry.PrevPtr]	358	cmp edi, [esi + IPv4_FRAGMENT_entry.PrevPtr]
359	jne .destroy_slot ; Damn, something screwed up, remove the whole slot (and free buffers too if possible!)	359	jne .destroy_slot ; Damn, something screwed up, remove the whole slot (and free buffers too if possible!)
360	mov edi, esi	360	mov edi, esi
361	mov esi, [esi + IPv4_FRAGMENT_entry.NextPtr]	361	mov esi, [esi + IPv4_FRAGMENT_entry.NextPtr]
362	cmp esi, -1	362	cmp esi, -1
363	jne .find_last_entry	363	jne .find_last_entry
364	; We found the last entry (pointer is now in edi)	364	; We found the last entry (pointer is now in edi)
365	; We are going to overwrite the ethernet header in received packet with a FRAGMENT_entry structure	365	; We are going to overwrite the ethernet header in received packet with a FRAGMENT_entry structure
366		366
367	pop eax ; pointer to packet	367	pop eax ; pointer to packet
368	mov [edi + IPv4_FRAGMENT_entry.NextPtr], eax ; update pointer of previous entry to the new entry	368	mov [edi + IPv4_FRAGMENT_entry.NextPtr], eax ; update pointer of previous entry to the new entry
369	mov [eax + IPv4_FRAGMENT_entry.NextPtr], -1	369	mov [eax + IPv4_FRAGMENT_entry.NextPtr], -1
370	mov [eax + IPv4_FRAGMENT_entry.PrevPtr], edi	370	mov [eax + IPv4_FRAGMENT_entry.PrevPtr], edi
371	mov [eax + IPv4_FRAGMENT_entry.Owner], ebx	371	mov [eax + IPv4_FRAGMENT_entry.Owner], ebx
372		372
373	ret	373	ret
374		374
375		375
376	;------------------------------------	376	;------------------------------------
377	; We have received the first fragment	377	; We have received the first fragment
378		378
379	.is_first_fragment:	379	.is_first_fragment:
380	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: First fragment packet received!\n"	380	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: First fragment packet received!\n"
381	; try to locate a free slot..	381	; try to locate a free slot..
382	mov ecx, IPv4_MAX_FRAGMENTS	382	mov ecx, IPv4_MAX_FRAGMENTS
383	mov esi, IPv4_FRAGMENT_LIST	383	mov esi, IPv4_FRAGMENT_LIST
384	.find_free_slot:	384	.find_free_slot:
385	cmp word [esi + IPv4_FRAGMENT_slot.ttl], 0	385	cmp word [esi + IPv4_FRAGMENT_slot.ttl], 0
386	je .found_free_slot	386	je .found_free_slot
387	add esi, sizeof.IPv4_FRAGMENT_slot	387	add esi, sizeof.IPv4_FRAGMENT_slot
388	loop .find_free_slot	388	loop .find_free_slot
389	jmp .dump ; If no free slot was found, dump the packet	389	jmp .dump ; If no free slot was found, dump the packet
390		390
391	.found_free_slot: ; We found a free slot, let's fill in the FRAGMENT_slot structure	391	.found_free_slot: ; We found a free slot, let's fill in the FRAGMENT_slot structure
392	mov [esi + IPv4_FRAGMENT_slot.ttl], 15 ; RFC recommends 15 secs as ttl	392	mov [esi + IPv4_FRAGMENT_slot.ttl], 15 ; RFC recommends 15 secs as ttl
393	mov ax, [edx + IPv4_header.Identification]	393	mov ax, [edx + IPv4_header.Identification]
394	mov [esi + IPv4_FRAGMENT_slot.id], ax	394	mov [esi + IPv4_FRAGMENT_slot.id], ax
395	mov eax, [edx + IPv4_header.SourceAddress]	395	mov eax, [edx + IPv4_header.SourceAddress]
396	mov [esi + IPv4_FRAGMENT_slot.SrcIP], eax	396	mov [esi + IPv4_FRAGMENT_slot.SrcIP], eax
397	mov eax, [edx + IPv4_header.DestinationAddress]	397	mov eax, [edx + IPv4_header.DestinationAddress]
398	mov [esi + IPv4_FRAGMENT_slot.DstIP], eax	398	mov [esi + IPv4_FRAGMENT_slot.DstIP], eax
399	pop eax	399	pop eax
400	mov [esi + IPv4_FRAGMENT_slot.ptr], eax	400	mov [esi + IPv4_FRAGMENT_slot.ptr], eax
401	; Now, replace ethernet header in original buffer with a FRAGMENT_entry structure	401	; Now, replace ethernet header in original buffer with a FRAGMENT_entry structure
402	mov [eax + IPv4_FRAGMENT_entry.NextPtr], -1	402	mov [eax + IPv4_FRAGMENT_entry.NextPtr], -1
403	mov [eax + IPv4_FRAGMENT_entry.PrevPtr], -1	403	mov [eax + IPv4_FRAGMENT_entry.PrevPtr], -1
404	mov [eax + IPv4_FRAGMENT_entry.Owner], ebx	404	mov [eax + IPv4_FRAGMENT_entry.Owner], ebx
405		405
406	ret	406	ret
407		407
408		408
409	;-----------------------------------	409	;-----------------------------------
410	; We have received the last fragment	410	; We have received the last fragment
411		411
412	.is_last_fragment:	412	.is_last_fragment:
413	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Last fragment packet received!\n"	413	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Last fragment packet received!\n"
414		414
415	call IPv4_find_fragment_slot	415	call IPv4_find_fragment_slot
416	cmp esi, -1	416	cmp esi, -1
417	je .dump	417	je .dump
418		418
419	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	419	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
420	push esi	420	push esi
421	xor eax, eax	421	xor eax, eax
422	or edi, -1	422	or edi, -1
423		423
424	.count_bytes:	424	.count_bytes:
425	cmp [esi + IPv4_FRAGMENT_entry.PrevPtr], edi	425	cmp [esi + IPv4_FRAGMENT_entry.PrevPtr], edi
426	jne .destroy_slot_pop ; Damn, something screwed up, remove the whole slot (and free buffers too if possible!)	426	jne .destroy_slot_pop ; Damn, something screwed up, remove the whole slot (and free buffers too if possible!)
427	mov cx, [esi + sizeof.IPv4_FRAGMENT_entry + IPv4_header.TotalLength] ; Add total length	427	mov cx, [esi + sizeof.IPv4_FRAGMENT_entry + IPv4_header.TotalLength] ; Add total length
428	xchg cl, ch	428	xchg cl, ch
429	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Packet size=%u\n", cx	429	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Packet size=%u\n", cx
430	add ax, cx	430	add ax, cx
431	movzx cx, [esi + sizeof.IPv4_FRAGMENT_entry + IPv4_header.VersionAndIHL] ; Sub Header length	431	movzx cx, [esi + sizeof.IPv4_FRAGMENT_entry + IPv4_header.VersionAndIHL] ; Sub Header length
432	and cx, 0x000F	432	and cx, 0x000F
433	shl cx, 2	433	shl cx, 2
434	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Header size=%u\n", cx	434	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Header size=%u\n", cx
435	sub ax, cx	435	sub ax, cx
436	mov edi, esi	436	mov edi, esi
437	mov esi, [esi + IPv4_FRAGMENT_entry.NextPtr]	437	mov esi, [esi + IPv4_FRAGMENT_entry.NextPtr]
438	cmp esi, -1	438	cmp esi, -1
439	jne .count_bytes	439	jne .count_bytes
440		440
441	mov esi, [esp+4]	441	mov esi, [esp+4]
442	mov [edi + IPv4_FRAGMENT_entry.NextPtr], esi ; Add this packet to the chain, this simplifies the following code	442	mov [edi + IPv4_FRAGMENT_entry.NextPtr], esi ; Add this packet to the chain, this simplifies the following code
443	mov [esi + IPv4_FRAGMENT_entry.NextPtr], -1	443	mov [esi + IPv4_FRAGMENT_entry.NextPtr], -1
444	mov [esi + IPv4_FRAGMENT_entry.PrevPtr], edi	444	mov [esi + IPv4_FRAGMENT_entry.PrevPtr], edi
445	mov [esi + IPv4_FRAGMENT_entry.Owner], ebx	445	mov [esi + IPv4_FRAGMENT_entry.Owner], ebx
446		446
447	mov cx, [edx + IPv4_header.TotalLength] ; Note: This time we dont substract Header length	447	mov cx, [edx + IPv4_header.TotalLength] ; Note: This time we dont substract Header length
448	xchg cl, ch	448	xchg cl, ch
449	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Packet size=%u\n", cx	449	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Packet size=%u\n", cx
450	add ax, cx	450	add ax, cx
451	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Total Received data size=%u\n", eax	451	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Total Received data size=%u\n", eax
452		452
453	push eax	453	push eax
454	mov ax, [edx + IPv4_header.FlagsAndFragmentOffset]	454	mov ax, [edx + IPv4_header.FlagsAndFragmentOffset]
455	xchg al, ah	455	xchg al, ah
456	shl ax, 3	456	shl ax, 3
457	add cx, ax	457	add cx, ax
458	pop eax	458	pop eax
459	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Total Fragment size=%u\n", ecx	459	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Total Fragment size=%u\n", ecx
460		460
461	cmp ax, cx	461	cmp ax, cx
462	jne .destroy_slot_pop	462	jne .destroy_slot_pop
463		463
464	push eax	464	push eax
465	push eax	465	push eax
466	call kernel_alloc	466	call kernel_alloc
467	test eax, eax	467	test eax, eax
468	je .destroy_slot_pop ; If we dont have enough space to allocate the buffer, discard all packets in slot	468	je .destroy_slot_pop ; If we dont have enough space to allocate the buffer, discard all packets in slot
469	mov edx, [esp+4] ; Get pointer to first fragment entry back in edx	469	mov edx, [esp+4] ; Get pointer to first fragment entry back in edx
470		470
471	.rebuild_packet_loop:	471	.rebuild_packet_loop:
472	movzx ecx, [edx + sizeof.IPv4_FRAGMENT_entry + IPv4_header.FlagsAndFragmentOffset] ; Calculate the fragment offset	472	movzx ecx, [edx + sizeof.IPv4_FRAGMENT_entry + IPv4_header.FlagsAndFragmentOffset] ; Calculate the fragment offset
473	xchg cl, ch ; intel byte order	473	xchg cl, ch ; intel byte order
474	shl cx, 3 ; multiply by 8 and clear first 3 bits	474	shl cx, 3 ; multiply by 8 and clear first 3 bits
475	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Fragment offset=%u\n", cx	475	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Fragment offset=%u\n", cx
476		476
477	lea edi, [eax + ecx] ; Notice that edi will be equal to eax for first fragment	477	lea edi, [eax + ecx] ; Notice that edi will be equal to eax for first fragment
478	movzx ebx, [edx + sizeof.IPv4_FRAGMENT_entry + IPv4_header.VersionAndIHL] ; Find header size (in ebx) of fragment	478	movzx ebx, [edx + sizeof.IPv4_FRAGMENT_entry + IPv4_header.VersionAndIHL] ; Find header size (in ebx) of fragment
479	and bx, 0x000F ;	479	and bx, 0x000F ;
480	shl bx, 2 ;	480	shl bx, 2 ;
481		481
482	lea esi, [edx + sizeof.IPv4_FRAGMENT_entry] ; Set esi to the correct begin of fragment	482	lea esi, [edx + sizeof.IPv4_FRAGMENT_entry] ; Set esi to the correct begin of fragment
483	movzx ecx, [edx + sizeof.IPv4_FRAGMENT_entry + IPv4_header.TotalLength] ; Calculate total length of fragment	483	movzx ecx, [edx + sizeof.IPv4_FRAGMENT_entry + IPv4_header.TotalLength] ; Calculate total length of fragment
484	xchg cl, ch ; intel byte order	484	xchg cl, ch ; intel byte order
485		485
486	cmp edi, eax ; Is this packet the first fragment ?	486	cmp edi, eax ; Is this packet the first fragment ?
487	je .first_fragment	487	je .first_fragment
488	sub cx, bx ; If not, dont copy the header	488	sub cx, bx ; If not, dont copy the header
489	add esi, ebx ;	489	add esi, ebx ;
490	.first_fragment:	490	.first_fragment:
491		491
492		492
493	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Copying %u bytes from 0x%x to 0x%x\n", ecx, esi, edi	493	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Copying %u bytes from 0x%x to 0x%x\n", ecx, esi, edi
494	push cx ; First copy dword-wise, then byte-wise	494	push cx ; First copy dword-wise, then byte-wise
495	shr cx, 2 ;	495	shr cx, 2 ;
496	rep movsd ;	496	rep movsd ;
497	pop cx ;	497	pop cx ;
498	and cx, 3 ;	498	and cx, 3 ;
499	rep movsb ;	499	rep movsb ;
500		500

Subversion Repositories Kolibri OS

(root)/kernel/trunk/network/IPv4.inc @ 5522 – Rev 5522 → 5584