WebSVN – Kolibri OS – Diff – /kernel/branches/Kolibri-acpi/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: 6011 $
 
IPv4_MAX_FRAGMENTS              = 64
IPv4_MAX_ROUTES                 = 64
 
IPv4_ROUTE_FLAG_UP              = 1 shl 0
IPv4_ROUTE_FLAG_GATEWAY         = 1 shl 1
IPv4_ROUTE_FLAG_HOST            = 1 shl 2
IPv4_ROUTE_FLAG_D               = 1 shl 3       ; Route was created by a redirect
IPv4_ROUTE_FLAG_M               = 1 shl 4       ; Route was modified by a redirect
 
struct  IPv4_header
 
        VersionAndIHL           db ?    ; Version[0-3 bits] and IHL(header length)[4-7 bits]
        TypeOfService           db ?    ; precedence [7-5] minimize delay [4], maximize throughput [3], maximize riliability [2] minimize momentary cost [1] and zero [0]
        TotalLength             dw ?
        Identification          dw ?
        FlagsAndFragmentOffset  dw ?    ; Flags[0-2] and FragmentOffset[3-15]
        TimeToLive              db ?    ;
        Protocol                db ?
        HeaderChecksum          dw ?
        SourceAddress           dd ?
        DestinationAddress      dd ?
 
ends
 
struct  IPv4_FRAGMENT_slot
 
        ttl                     dw ?    ; Time to live for this entry, 0 for empty slot's
        id                      dw ?    ; Identification field from IP header
        SrcIP                   dd ?    ; .. from IP header
        DstIP                   dd ?    ; .. from IP header
        ptr                     dd ?    ; Pointer to first packet
 
ends
 
struct  IPv4_FRAGMENT_entry             ; This structure will replace the ethernet header in fragmented ip packets
 
        PrevPtr                 dd ?    ; Pointer to previous fragment entry  (-1 for first packet)
        NextPtr                 dd ?    ; Pointer to next fragment entry (-1 for last packet)
        Owner                   dd ?    ; Pointer to structure of driver
                                rb 2    ; to match ethernet header size         ;;; FIXME
                                        ; Ip header begins here (we will need the IP header to re-construct the complete packet)
ends
 
struct  IPv4_ROUTE
 
        Destination             dd ?
        Gateway                 dd ?
        Flags                   dd ?
        Use                     dd ?
        Interface               dd ?
 
ends
 
 
uglobal
align 4
 
        IP_LIST                 rd NET_DEVICES_MAX
        SUBNET_LIST             rd NET_DEVICES_MAX
        DNS_LIST                rd NET_DEVICES_MAX
        GATEWAY_LIST            rd NET_DEVICES_MAX
        BROADCAST_LIST          rd NET_DEVICES_MAX
 
        IPv4_packets_tx         rd NET_DEVICES_MAX
        IPv4_packets_rx         rd NET_DEVICES_MAX
        IPv4_packets_dumped     rd NET_DEVICES_MAX
 
        IPv4_FRAGMENT_LIST      rb IPv4_MAX_FRAGMENTS * sizeof.IPv4_FRAGMENT_slot
 
        IPv4_ROUTES             rd IPv4_MAX_ROUTES * sizeof.IPv4_ROUTE
 
endg
 
 
 
;-----------------------------------------------------------------;
 
;                                                                 ;
 
; ipv4_init: Resets all IPv4 variables                            ;
;                                                                 ;
;-----------------------------------------------------------------;
macro   ipv4_init {
 
        xor     eax, eax
        mov     edi, IP_LIST
        mov     ecx, 7*NET_DEVICES_MAX + (sizeof.IPv4_FRAGMENT_slot*IPv4_MAX_FRAGMENTS)/4
        rep stosd
 
}
 
 
 
;-----------------------------------------------------------------;
;                                                                 ;
 
; Decrease TimeToLive of all fragment slots                       ;
;                                                                 ;
;-----------------------------------------------------------------;
macro ipv4_decrease_fragment_ttls {
 
local   .loop, .next
 
        mov     esi, IPv4_FRAGMENT_LIST
        mov     ecx, IPv4_MAX_FRAGMENTS
  .loop:
        cmp     [esi + IPv4_FRAGMENT_slot.ttl], 0
        je      .next
        dec     [esi + IPv4_FRAGMENT_slot.ttl]
        jz      .died
  .next:
        add     esi, sizeof.IPv4_FRAGMENT_slot
        dec     ecx
        jnz     .loop
        jmp     .done
 
  .died:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4 Fragment slot timed-out!\n"
;;; TODO: clear all entry's of timed-out slot
        jmp     .next
 
  .done:
}
 
 
 
macro ipv4_checksum ptr {
 
; This is the fast procedure to create or check an IP header without options
; To create a new checksum, the checksum field must be set to 0 before computation
; To check an existing checksum, leave the checksum as is, and it will be 0 after this procedure, if it was correct
 
        push    ebx
        xor     ebx, ebx
        add     bl, [ptr+1]
        adc     bh, [ptr+0]
 
        adc     bl, [ptr+3]
        adc     bh, [ptr+2]
 
        adc     bl, [ptr+5]
        adc     bh, [ptr+4]
 
        adc     bl, [ptr+7]
        adc     bh, [ptr+6]
 
        adc     bl, [ptr+9]
        adc     bh, [ptr+8]
 
; we skip 11th and 12th byte, they are the checksum bytes and should be 0 for re-calculation
 
        adc     bl, [ptr+13]
        adc     bh, [ptr+12]
 
        adc     bl, [ptr+15]
        adc     bh, [ptr+14]
 
        adc     bl, [ptr+17]
        adc     bh, [ptr+16]
 
        adc     bl, [ptr+19]
        adc     bh, [ptr+18]
 
        adc     ebx, 0
 
        push    ecx
        mov     ecx, ebx
        shr     ecx, 16
        and     ebx, 0xffff
        add     ebx, ecx
 
        mov     ecx, ebx
        shr     ecx, 16
        add     ebx, ecx
 
        not     bx
        jnz     .not_zero
        dec     bx
  .not_zero:
        xchg    bl, bh
        pop     ecx
 
        neg     word [ptr+10]           ; zero will stay zero so we just get the checksum
        add     word [ptr+10], bx       ;  , else we will get (new checksum - old checksum) in the end, wich should be 0 :)
        pop     ebx
 
}
 
 
 
 
;-----------------------------------------------------------------;
 
;                                                                 ;
; ipv4_input: Check if IPv4 Packet isnt damaged and call          ;
 
; appropriate handler. (TCP/UDP/ICMP/..)                          ;
 
; We will also re-construct fragmented packets.                   ;
;                                                                 ;
;  IN:  Pointer to buffer in [esp]                                ;
;       pointer to device struct in ebx                           ;
;       pointer to IPv4 header in edx                             ;
;       size of IPv4 packet in ecx                                ;
;                                                                 ;
 
;  OUT: /                                                         ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
ipv4_input:
 
        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
 
        call    net_ptr_to_num4
        cmp     edi, -1
        je      .invalid_device
 
;-------------------------------
; 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 matches
 
; local ip (Using RFC1122 strong end system model)
        mov     eax, [edx + IPv4_header.DestinationAddress]
        cmp     eax, [IP_LIST + edi]
        je      .ip_ok
 
; network layer broadcast
        cmp     eax, [BROADCAST_LIST + edi]
        je      .ip_ok
 
; physical layer broadcast (255.255.255.255)
        cmp     eax, 0xffffffff
        je      .ip_ok
 
; multicast (224.0.0.0/4 = 224.0.0.0 to 239.255.255.255)
        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                                        ;
 
        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
 
;-------------------------------
; Look for a matching RAW socket
        pusha
        mov     ecx, socket_mutex
        call    mutex_lock
        popa
 
        add     ecx, esi
        sub     ecx, edx
        mov     esi, edx
        movzx   edx, al
        mov     eax, net_sockets
  .next_socket:
        mov     eax, [eax + SOCKET.NextPtr]
        or      eax, eax
        jz      .dump_unlock
 
        cmp     [eax + SOCKET.Domain], AF_INET4
        jne     .next_socket
 
        cmp     [eax + SOCKET.Protocol], edx
        jne     .next_socket
 
        pusha
        mov     ecx, socket_mutex
        call    mutex_unlock
        popa
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_input: found matching RAW socket: 0x%x\n", eax
 
        pusha
        lea     ecx, [eax + SOCKET.mutex]
        call    mutex_lock
        popa
 
        jmp     socket_input
 
  .dump_unlock:
 
        pusha
        mov     ecx, socket_mutex
        call    mutex_unlock
        popa
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_input: unknown protocol %u\n", al
 
  .dump:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_input: dumping\n"
        inc     [IPv4_packets_dumped + edi]
        call    net_buff_free
        ret
 
  .invalid_device:
        DEBUGF  DEBUG_NETWORK_ERROR, "IPv4_input: packet originated from invalid device\n"
        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
 
 
 
 
 
 
;-----------------------------------------------------------------;
;                                                                 ;
 
; ipv4_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:  al = protocol                                              ;
;       ah = TTL                                                   ;
;       ebx = device ptr (or 0 to let IP layer decide)             ;
;       ecx = data length                                          ;
;       edx = Source IP                                            ;
 
;       edi = Destination IP                                       ;
;                                                                  ;
; OUT:  eax = pointer to buffer start                              ;
;       eax = 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 ax edi
        mov     eax, edi
        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, 4
        pop     eax
        DEBUGF  DEBUG_NETWORK_ERROR, "IPv4_output: ip=0x%x\n", eax
        add     esp, 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
 
        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+8+4+4
        mov     ebx, ENOBUFS            ; FIXME: NOBUFS or MSGSIZE error
        or      eax, -1
        ret
 
  .arp_error:
        add     esp, 8+4+4
        mov     ebx, ENOTCONN
        or      eax, -1
        ret
 
 
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; ipv4_fragment                                                   ;
;                                                                 ;
;  IN:  [esp] = ptr to packet buffer to fragment                  ;
;       edi = ptrr to ip header in that buffer                    ;
 
;       ebx = device ptr                                          ;
;                                                                 ;
 
;  OUT: /                                                         ;
;                                                                 ;
;-----------------------------------------------------------------;
proc ipv4_fragment stdcall buffer
 
locals
        offset          dd ?
        headerlength    dd ?
        headerptr       dd ?
        dataptr         dd ?
        remaining       dd ?
        segmentsize     dd ?
endl
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_fragment\n"
 
; We must be able to put at least 8 bytes per segment
        movzx   eax, byte[edi]          ; IHL
        and     eax, 0xf
        shl     eax, 2
        mov     [headerlength], eax
        add     eax, 8
        mov     ecx, [ebx + NET_DEVICE.mtu]
        and     ecx, not 11b
        cmp     ecx, eax
        jb      .fail
 
        mov     [edi + IPv4_header.HeaderChecksum], 0
 
        mov     [segmentsize], ecx
        mov     [headerptr], edi
        movzx   ecx, [edi + IPv4_header.TotalLength]
        xchg    cl, ch
        sub     ecx, [headerlength]
        mov     [remaining], ecx
        mov     [offset], 0
 
        add     edi, [headerlength]
        mov     [dataptr], edi
 
  .loop:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "Ipv4_fragment: new fragment"
 
        mov     ecx, [segmentsize]
        cmp     ecx, [remaining]
        jbe     @f
        mov     ecx, [remaining]
  @@:
 
        mov     ax, ETHER_PROTO_IPv4
        mov     edx, [esp]
        add     edx, [edx + NET_BUFF.offset]
;        add     edx, ETH_header.DstMAC         ; = 0
        call    ETH_output
        jz      .fail
 
        push    edi
        mov     edx, ecx
 
; copy header
        mov     esi, [headerptr]
        mov     ecx, [headerlength]
        shr     ecx, 2
        rep movsd
 
; copy data
        mov     esi, [dataptr]
        add     esi, [offset]
        mov     ecx, edx
        sub     ecx, [headerlength]
        shr     ecx, 2
        rep movsd
        pop     edi
 
; now, correct header
; packet length
        mov     ax, dx
        xchg    al, ah
        mov     [edi + IPv4_header.TotalLength], ax
 
; offset
        mov     eax, [offset]
        xchg    al, ah
 
        sub     edx, [headerlength]
        sub     [remaining], edx
        je      @f
        jb      .fail
        or      ah, 1 shl 2             ; more fragments
        add     [offset], edx
  @@:
        mov     [edi + IPv4_header.FlagsAndFragmentOffset], ax
 
; Send the fragment
        IPv4_checksum edi
        call    [ebx + NET_DEVICE.transmit]
 
        cmp     [remaining], 0
        jne     .loop
 
        call    NET_BUFF_free
        ret
 
      .fail:
        DEBUGF  DEBUG_NETWORK_ERROR, "Ipv4_fragment: failed\n"
        call    NET_BUFF_free
        ret
 
endp
 
 
 
 
;-----------------------------------------------------------------;
;                                                                 ;
 
; 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: ax = fragment number                                       ;
;                                                                 ;
;-----------------------------------------------------------------;
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 on success                                        ;
;       eax = -1 on error                                         ;
 
;       ebx = error code on error                                 ;
;                                                                 ;
;-----------------------------------------------------------------;
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]
 
        lea     ecx, [eax + SOCKET.mutex]
        call    mutex_unlock
 
        xor     eax, eax
        ret
 
 
 
;-----------------------------------------------------------------;
;                                                                 ;
 
; ipv4_API: Part of system function 76.                           ;
 
;                                                                 ;
;  IN:  bl = subfunction number                                   ;
;       bh = device number                                        ;
 
;       ecx, edx, .. depends on subfunction                       ;
;                                                                 ;
 
; OUT:  depends on subfunction                                    ;
;                                                                 ;
;-----------------------------------------------------------------;
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 5984	Rev 6078
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: 5842 $	19	$Revision: 6011 $
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	;-----------------------------------------------------------------	-
96	;	95	;-----------------------------------------------------------------;
97	; IPv4_init	-
98	;	96	; ;
99	; This function resets all IP variables	-
-		97	; ipv4_init: Resets all IPv4 variables ;
100	;	98	; ;
101	;-----------------------------------------------------------------	99	;-----------------------------------------------------------------;
102	macro IPv4_init {	100	macro ipv4_init {
103		101
104	xor eax, eax	102	xor eax, eax
105	mov edi, IP_LIST	103	mov edi, IP_LIST
106	mov ecx, 7NET_DEVICES_MAX + (sizeof.IPv4_FRAGMENT_slotIPv4_MAX_FRAGMENTS)/4	104	mov ecx, 7NET_DEVICES_MAX + (sizeof.IPv4_FRAGMENT_slotIPv4_MAX_FRAGMENTS)/4
107	rep stosd	105	rep stosd
108		106
109	}	107	}
110		108
111		109
112	;-----------------------------------------------------------------	-
-		110	;-----------------------------------------------------------------;
113	;	111	; ;
114	; Decrease TimeToLive of all fragment slots	-
-		112	; Decrease TimeToLive of all fragment slots ;
115	;	113	; ;
116	;-----------------------------------------------------------------	114	;-----------------------------------------------------------------;
117	macro IPv4_decrease_fragment_ttls {	115	macro ipv4_decrease_fragment_ttls {
118		116
119	local .loop, .next	117	local .loop, .next
120		118
121	mov esi, IPv4_FRAGMENT_LIST	119	mov esi, IPv4_FRAGMENT_LIST
122	mov ecx, IPv4_MAX_FRAGMENTS	120	mov ecx, IPv4_MAX_FRAGMENTS
123	.loop:	121	.loop:
124	cmp [esi + IPv4_FRAGMENT_slot.ttl], 0	122	cmp [esi + IPv4_FRAGMENT_slot.ttl], 0
125	je .next	123	je .next
126	dec [esi + IPv4_FRAGMENT_slot.ttl]	124	dec [esi + IPv4_FRAGMENT_slot.ttl]
127	jz .died	125	jz .died
128	.next:	126	.next:
129	add esi, sizeof.IPv4_FRAGMENT_slot	127	add esi, sizeof.IPv4_FRAGMENT_slot
130	dec ecx	128	dec ecx
131	jnz .loop	129	jnz .loop
132	jmp .done	130	jmp .done
133		131
134	.died:	132	.died:
135	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4 Fragment slot timed-out!\n"	133	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4 Fragment slot timed-out!\n"
136	;;; TODO: clear all entry's of timed-out slot	134	;;; TODO: clear all entry's of timed-out slot
137	jmp .next	135	jmp .next
138		136
139	.done:	137	.done:
140	}	138	}
141		139
142		140
143		141
144	macro IPv4_checksum ptr {	142	macro ipv4_checksum ptr {
145		143
146	; This is the fast procedure to create or check an IP header without options	144	; 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	145	; 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	146	; To check an existing checksum, leave the checksum as is, and it will be 0 after this procedure, if it was correct
149		147
150	push ebx	148	push ebx
151	xor ebx, ebx	149	xor ebx, ebx
152	add bl, [ptr+1]	150	add bl, [ptr+1]
153	adc bh, [ptr+0]	151	adc bh, [ptr+0]
154		152
155	adc bl, [ptr+3]	153	adc bl, [ptr+3]
156	adc bh, [ptr+2]	154	adc bh, [ptr+2]
157		155
158	adc bl, [ptr+5]	156	adc bl, [ptr+5]
159	adc bh, [ptr+4]	157	adc bh, [ptr+4]
160		158
161	adc bl, [ptr+7]	159	adc bl, [ptr+7]
162	adc bh, [ptr+6]	160	adc bh, [ptr+6]
163		161
164	adc bl, [ptr+9]	162	adc bl, [ptr+9]
165	adc bh, [ptr+8]	163	adc bh, [ptr+8]
166		164
167	; we skip 11th and 12th byte, they are the checksum bytes and should be 0 for re-calculation	165	; we skip 11th and 12th byte, they are the checksum bytes and should be 0 for re-calculation
168		166
169	adc bl, [ptr+13]	167	adc bl, [ptr+13]
170	adc bh, [ptr+12]	168	adc bh, [ptr+12]
171		169
172	adc bl, [ptr+15]	170	adc bl, [ptr+15]
173	adc bh, [ptr+14]	171	adc bh, [ptr+14]
174		172
175	adc bl, [ptr+17]	173	adc bl, [ptr+17]
176	adc bh, [ptr+16]	174	adc bh, [ptr+16]
177		175
178	adc bl, [ptr+19]	176	adc bl, [ptr+19]
179	adc bh, [ptr+18]	177	adc bh, [ptr+18]
180		178
181	adc ebx, 0	179	adc ebx, 0
182		180
183	push ecx	181	push ecx
184	mov ecx, ebx	182	mov ecx, ebx
185	shr ecx, 16	183	shr ecx, 16
186	and ebx, 0xffff	184	and ebx, 0xffff
187	add ebx, ecx	185	add ebx, ecx
188		186
189	mov ecx, ebx	187	mov ecx, ebx
190	shr ecx, 16	188	shr ecx, 16
191	add ebx, ecx	189	add ebx, ecx
192		190
193	not bx	191	not bx
194	jnz .not_zero	192	jnz .not_zero
195	dec bx	193	dec bx
196	.not_zero:	194	.not_zero:
197	xchg bl, bh	195	xchg bl, bh
198	pop ecx	196	pop ecx
199		197
200	neg word [ptr+10] ; zero will stay zero so we just get the checksum	198	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 :)	199	add word [ptr+10], bx ; , else we will get (new checksum - old checksum) in the end, wich should be 0 :)
202	pop ebx	200	pop ebx
203		201
204	}	202	}
205		203
206		204
207		205
208	;-----------------------------------------------------------------	-
209	;	206	;-----------------------------------------------------------------;
210	; IPv4_input:	-
211	;	207	; ;
212	; Will check if IPv4 Packet isnt damaged	208	; ipv4_input: Check if IPv4 Packet isnt damaged and call ;
213	; and call appropriate handler. (TCP/UDP/ICMP/..)	-
214	;	209	; appropriate handler. (TCP/UDP/ICMP/..) ;
215	; It will also re-construct fragmented packets	-
-		210	; We will also re-construct fragmented packets. ;
216	;	211	; ;
217	; IN: Pointer to buffer in [esp]	212	; IN: Pointer to buffer in [esp] ;
218	; pointer to device struct in ebx	213	; pointer to device struct in ebx ;
219	; pointer to IPv4 header in edx	214	; pointer to IPv4 header in edx ;
-		215	; size of IPv4 packet in ecx ;
220	; size of IPv4 packet in ecx	216	; ;
221	; OUT: /	-
-		217	; OUT: / ;
222	;	218	; ;
223	;-----------------------------------------------------------------	219	;-----------------------------------------------------------------;
224	align 4	220	align 4
225	IPv4_input:	221	ipv4_input:
226		222
227	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: packet from %u.%u.%u.%u ",\	223	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: packet from %u.%u.%u.%u ",\
228	[edx + IPv4_header.SourceAddress + 0]:1,[edx + IPv4_header.SourceAddress + 1]:1,\	224	[edx + IPv4_header.SourceAddress + 0]:1,[edx + IPv4_header.SourceAddress + 1]:1,\
229	[edx + IPv4_header.SourceAddress + 2]:1,[edx + IPv4_header.SourceAddress + 3]:1	225	[edx + IPv4_header.SourceAddress + 2]:1,[edx + IPv4_header.SourceAddress + 3]:1
230	DEBUGF DEBUG_NETWORK_VERBOSE, "to %u.%u.%u.%u\n",\	226	DEBUGF DEBUG_NETWORK_VERBOSE, "to %u.%u.%u.%u\n",\
231	[edx + IPv4_header.DestinationAddress + 0]:1,[edx + IPv4_header.DestinationAddress + 1]:1,\	227	[edx + IPv4_header.DestinationAddress + 0]:1,[edx + IPv4_header.DestinationAddress + 1]:1,\
232	[edx + IPv4_header.DestinationAddress + 2]:1,[edx + IPv4_header.DestinationAddress + 3]:1	228	[edx + IPv4_header.DestinationAddress + 2]:1,[edx + IPv4_header.DestinationAddress + 3]:1
233		229
234	call NET_ptr_to_num4	230	call net_ptr_to_num4
235	cmp edi, -1	231	cmp edi, -1
236	je .invalid_device	232	je .invalid_device
237		233
238	;-------------------------------	234	;-------------------------------
239	; re-calculate the checksum	235	; re-calculate the checksum
240		236
241	IPv4_checksum edx	237	ipv4_checksum edx
242	jnz .dump ; if checksum isn't valid then dump packet	238	jnz .dump ; if checksum isn't valid then dump packet
243		239
244	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Checksum ok\n"	240	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Checksum ok\n"
245		241
246	;--------------------------------	242	;--------------------------------
247	; Check if destination IP matches	243	; Check if destination IP matches
248		244
249	; local ip (Using RFC1122 strong end system model)	245	; local ip (Using RFC1122 strong end system model)
250	mov eax, [edx + IPv4_header.DestinationAddress]	246	mov eax, [edx + IPv4_header.DestinationAddress]
251	cmp eax, [IP_LIST + edi]	247	cmp eax, [IP_LIST + edi]
252	je .ip_ok	248	je .ip_ok
253		249
254	; network layer broadcast	250	; network layer broadcast
255	cmp eax, [BROADCAST_LIST + edi]	251	cmp eax, [BROADCAST_LIST + edi]
256	je .ip_ok	252	je .ip_ok
257		253
258	; physical layer broadcast (255.255.255.255)	254	; physical layer broadcast (255.255.255.255)
259	cmp eax, 0xffffffff	255	cmp eax, 0xffffffff
260	je .ip_ok	256	je .ip_ok
261		257
262	; multicast (224.0.0.0/4 = 224.0.0.0 to 239.255.255.255)	258	; multicast (224.0.0.0/4 = 224.0.0.0 to 239.255.255.255)
263	and eax, 0x0fffffff	259	and eax, 0x0fffffff
264	cmp eax, 224	260	cmp eax, 224
265	je .ip_ok	261	je .ip_ok
266		262
267	; maybe we just dont have an IP yet and should accept everything on the IP level	263	; maybe we just dont have an IP yet and should accept everything on the IP level
268	cmp [IP_LIST + edi], 0	264	cmp [IP_LIST + edi], 0
269	je .ip_ok	265	je .ip_ok
270		266
271	; or it's just not meant for us.. :(	267	; or it's just not meant for us.. :(
272	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Destination address does not match!\n"	268	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Destination address does not match!\n"
273	jmp .dump	269	jmp .dump
274		270
275	;------------------------	271	;------------------------
276	; Now we can update stats	272	; Now we can update stats
277		273
278	.ip_ok:	274	.ip_ok:
279	inc [IPv4_packets_rx + edi]	275	inc [IPv4_packets_rx + edi]
280		276
281	;----------------------------------	277	;----------------------------------
282	; Check if the packet is fragmented	278	; Check if the packet is fragmented
283		279
284	test [edx + IPv4_header.FlagsAndFragmentOffset], 1 shl 5 ; Is 'more fragments' flag set ?	280	test [edx + IPv4_header.FlagsAndFragmentOffset], 1 shl 5 ; Is 'more fragments' flag set ?
285	jnz .has_fragments ; If so, we definately have a fragmented packet	281	jnz .has_fragments ; If so, we definately have a fragmented packet
286		282
287	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	283	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
288	jnz .is_last_fragment	284	jnz .is_last_fragment
289		285
290	;-------------------------------------------------------------------	286	;-------------------------------------------------------------------
291	; No, it's just a regular IP packet, pass it to the higher protocols	287	; No, it's just a regular IP packet, pass it to the higher protocols
292		288
293	.handle_it: ; We reach here if packet hasnt been fragmented, or when it already has been re-constructed	289	.handle_it: ; We reach here if packet hasnt been fragmented, or when it already has been re-constructed
294		290
295	movzx esi, [edx + IPv4_header.VersionAndIHL] ; Calculate Header length by using IHL field	291	movzx esi, [edx + IPv4_header.VersionAndIHL] ; Calculate Header length by using IHL field
296	and esi, 0x0000000f ;	292	and esi, 0x0000000f ;
297	shl esi, 2 ;	293	shl esi, 2 ;
298		294
299	movzx ecx, [edx + IPv4_header.TotalLength] ; Calculate length of encapsulated Packet	295	movzx ecx, [edx + IPv4_header.TotalLength] ; Calculate length of encapsulated Packet
300	xchg cl, ch ;	296	xchg cl, ch ;
301	sub ecx, esi ;	297	sub ecx, esi ;
302		298
303	mov al, [edx + IPv4_header.Protocol]	299	mov al, [edx + IPv4_header.Protocol]
304	add esi, edx ; make esi ptr to data	300	add esi, edx ; make esi ptr to data
305		301
306	cmp al, IP_PROTO_TCP	302	cmp al, IP_PROTO_TCP
307	je TCP_input	303	je tcp_input
308		304
309	cmp al, IP_PROTO_UDP	305	cmp al, IP_PROTO_UDP
310	je UDP_input	306	je udp_input
311		307
312	cmp al, IP_PROTO_ICMP	308	cmp al, IP_PROTO_ICMP
313	je ICMP_input	309	je icmp_input
314		310
315	;-------------------------------	311	;-------------------------------
316	; Look for a matching RAW socket	312	; Look for a matching RAW socket
317	pusha	313	pusha
318	mov ecx, socket_mutex	314	mov ecx, socket_mutex
319	call mutex_lock	315	call mutex_lock
320	popa	316	popa
321		317
322	add ecx, esi	318	add ecx, esi
323	sub ecx, edx	319	sub ecx, edx
324	mov esi, edx	320	mov esi, edx
325	movzx edx, al	321	movzx edx, al
326	mov eax, net_sockets	322	mov eax, net_sockets
327	.next_socket:	323	.next_socket:
328	mov eax, [eax + SOCKET.NextPtr]	324	mov eax, [eax + SOCKET.NextPtr]
329	or eax, eax	325	or eax, eax
330	jz .dump_unlock	326	jz .dump_unlock
331		327
332	cmp [eax + SOCKET.Domain], AF_INET4	328	cmp [eax + SOCKET.Domain], AF_INET4
333	jne .next_socket	329	jne .next_socket
334		330
335	cmp [eax + SOCKET.Protocol], edx	331	cmp [eax + SOCKET.Protocol], edx
336	jne .next_socket	332	jne .next_socket
337		333
338	pusha	334	pusha
339	mov ecx, socket_mutex	335	mov ecx, socket_mutex
340	call mutex_unlock	336	call mutex_unlock
341	popa	337	popa
342		338
343	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: found matching RAW socket: 0x%x\n", eax	339	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: found matching RAW socket: 0x%x\n", eax
344		340
345	pusha	341	pusha
346	lea ecx, [eax + SOCKET.mutex]	342	lea ecx, [eax + SOCKET.mutex]
347	call mutex_lock	343	call mutex_lock
348	popa	344	popa
349		345
350	jmp SOCKET_input	346	jmp socket_input
351		347
352	.dump_unlock:	348	.dump_unlock:
353		349
354	pusha	350	pusha
355	mov ecx, socket_mutex	351	mov ecx, socket_mutex
356	call mutex_unlock	352	call mutex_unlock
357	popa	353	popa
358		354
359	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: unknown protocol %u\n", al	355	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: unknown protocol %u\n", al
360		356
361	.dump:	357	.dump:
362	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: dumping\n"	358	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: dumping\n"
363	inc [IPv4_packets_dumped + edi]	359	inc [IPv4_packets_dumped + edi]
364	call NET_BUFF_free	360	call net_buff_free
365	ret	361	ret
366		362
367	.invalid_device:	363	.invalid_device:
368	DEBUGF DEBUG_NETWORK_ERROR, "IPv4_input: packet originated from invalid device\n"	364	DEBUGF DEBUG_NETWORK_ERROR, "IPv4_input: packet originated from invalid device\n"
369	call NET_BUFF_free	365	call net_buff_free
370	ret	366	ret
371		367
372		368
373	;---------------------------	369	;---------------------------
374	; Fragmented packet handler	370	; Fragmented packet handler
375		371
376		372
377	.has_fragments:	373	.has_fragments:
378	movzx eax, [edx + IPv4_header.FlagsAndFragmentOffset]	374	movzx eax, [edx + IPv4_header.FlagsAndFragmentOffset]
379	xchg al, ah	375	xchg al, ah
380	shl ax, 3	376	shl ax, 3
381		377
382	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: fragmented packet offset=%u id=%x ptr=0x%x\n", ax, [edx + IPv4_header.Identification]:4, edx	378	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: fragmented packet offset=%u id=%x ptr=0x%x\n", ax, [edx + IPv4_header.Identification]:4, edx
383		379
384	test ax, ax ; Is this the first packet of the fragment?	380	test ax, ax ; Is this the first packet of the fragment?
385	jz .is_first_fragment	381	jz .is_first_fragment
386		382
387		383
388	;-------------------------------------------------------	384	;-------------------------------------------------------
389	; We have a fragmented IP packet, but it's not the first	385	; We have a fragmented IP packet, but it's not the first
390		386
391	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Middle fragment packet received!\n"	387	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Middle fragment packet received!\n"
392		388
393	call IPv4_find_fragment_slot	389	call ipv4_find_fragment_slot
394	cmp esi, -1	390	cmp esi, -1
395	je .dump	391	je .dump
396		392
397	mov [esi + IPv4_FRAGMENT_slot.ttl], 15 ; Reset the ttl	393	mov [esi + IPv4_FRAGMENT_slot.ttl], 15 ; Reset the ttl
398	mov esi, [esi + IPv4_FRAGMENT_slot.ptr]	394	mov esi, [esi + IPv4_FRAGMENT_slot.ptr]
399	or edi, -1	395	or edi, -1
400	.find_last_entry: ; The following routine will try to find the last entry	396	.find_last_entry: ; The following routine will try to find the last entry
401	cmp edi, [esi + IPv4_FRAGMENT_entry.PrevPtr]	397	cmp edi, [esi + IPv4_FRAGMENT_entry.PrevPtr]
402	jne .destroy_slot ; Damn, something screwed up, remove the whole slot (and free buffers too if possible!)	398	jne .destroy_slot ; Damn, something screwed up, remove the whole slot (and free buffers too if possible!)
403	mov edi, esi	399	mov edi, esi
404	mov esi, [esi + IPv4_FRAGMENT_entry.NextPtr]	400	mov esi, [esi + IPv4_FRAGMENT_entry.NextPtr]
405	cmp esi, -1	401	cmp esi, -1
406	jne .find_last_entry	402	jne .find_last_entry
407	; We found the last entry (pointer is now in edi)	403	; We found the last entry (pointer is now in edi)
408	; We are going to overwrite the ethernet header in received packet with a FRAGMENT_entry structure	404	; We are going to overwrite the ethernet header in received packet with a FRAGMENT_entry structure
409		405
410	pop eax ; pointer to packet	406	pop eax ; pointer to packet
411	mov [edi + IPv4_FRAGMENT_entry.NextPtr], eax ; update pointer of previous entry to the new entry	407	mov [edi + IPv4_FRAGMENT_entry.NextPtr], eax ; update pointer of previous entry to the new entry
412	mov [eax + IPv4_FRAGMENT_entry.NextPtr], -1	408	mov [eax + IPv4_FRAGMENT_entry.NextPtr], -1
413	mov [eax + IPv4_FRAGMENT_entry.PrevPtr], edi	409	mov [eax + IPv4_FRAGMENT_entry.PrevPtr], edi
414	mov [eax + IPv4_FRAGMENT_entry.Owner], ebx	410	mov [eax + IPv4_FRAGMENT_entry.Owner], ebx
415		411
416	ret	412	ret
417		413
418		414
419	;------------------------------------	415	;------------------------------------
420	; We have received the first fragment	416	; We have received the first fragment
421		417
422	.is_first_fragment:	418	.is_first_fragment:
423	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: First fragment packet received!\n"	419	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: First fragment packet received!\n"
424	; try to locate a free slot..	420	; try to locate a free slot..
425	mov ecx, IPv4_MAX_FRAGMENTS	421	mov ecx, IPv4_MAX_FRAGMENTS
426	mov esi, IPv4_FRAGMENT_LIST	422	mov esi, IPv4_FRAGMENT_LIST
427	.find_free_slot:	423	.find_free_slot:
428	cmp word [esi + IPv4_FRAGMENT_slot.ttl], 0	424	cmp word [esi + IPv4_FRAGMENT_slot.ttl], 0
429	je .found_free_slot	425	je .found_free_slot
430	add esi, sizeof.IPv4_FRAGMENT_slot	426	add esi, sizeof.IPv4_FRAGMENT_slot
431	loop .find_free_slot	427	loop .find_free_slot
432	jmp .dump ; If no free slot was found, dump the packet	428	jmp .dump ; If no free slot was found, dump the packet
433		429
434	.found_free_slot: ; We found a free slot, let's fill in the FRAGMENT_slot structure	430	.found_free_slot: ; We found a free slot, let's fill in the FRAGMENT_slot structure
435	mov [esi + IPv4_FRAGMENT_slot.ttl], 15 ; RFC recommends 15 secs as ttl	431	mov [esi + IPv4_FRAGMENT_slot.ttl], 15 ; RFC recommends 15 secs as ttl
436	mov ax, [edx + IPv4_header.Identification]	432	mov ax, [edx + IPv4_header.Identification]
437	mov [esi + IPv4_FRAGMENT_slot.id], ax	433	mov [esi + IPv4_FRAGMENT_slot.id], ax
438	mov eax, [edx + IPv4_header.SourceAddress]	434	mov eax, [edx + IPv4_header.SourceAddress]
439	mov [esi + IPv4_FRAGMENT_slot.SrcIP], eax	435	mov [esi + IPv4_FRAGMENT_slot.SrcIP], eax
440	mov eax, [edx + IPv4_header.DestinationAddress]	436	mov eax, [edx + IPv4_header.DestinationAddress]
441	mov [esi + IPv4_FRAGMENT_slot.DstIP], eax	437	mov [esi + IPv4_FRAGMENT_slot.DstIP], eax
442	pop eax	438	pop eax
443	mov [esi + IPv4_FRAGMENT_slot.ptr], eax	439	mov [esi + IPv4_FRAGMENT_slot.ptr], eax
444	; Now, replace ethernet header in original buffer with a FRAGMENT_entry structure	440	; Now, replace ethernet header in original buffer with a FRAGMENT_entry structure
445	mov [eax + IPv4_FRAGMENT_entry.NextPtr], -1	441	mov [eax + IPv4_FRAGMENT_entry.NextPtr], -1
446	mov [eax + IPv4_FRAGMENT_entry.PrevPtr], -1	442	mov [eax + IPv4_FRAGMENT_entry.PrevPtr], -1
447	mov [eax + IPv4_FRAGMENT_entry.Owner], ebx	443	mov [eax + IPv4_FRAGMENT_entry.Owner], ebx
448		444
449	ret	445	ret
450		446
451		447
452	;-----------------------------------	448	;-----------------------------------
453	; We have received the last fragment	449	; We have received the last fragment
454		450
455	.is_last_fragment:	451	.is_last_fragment:
456	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Last fragment packet received!\n"	452	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Last fragment packet received!\n"
457		453
458	call IPv4_find_fragment_slot	454	call ipv4_find_fragment_slot
459	cmp esi, -1	455	cmp esi, -1
460	je .dump	456	je .dump
461		457
462	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	458	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
463	push esi	459	push esi
464	xor eax, eax	460	xor eax, eax
465	or edi, -1	461	or edi, -1
466		462
467	.count_bytes:	463	.count_bytes:
468	cmp [esi + IPv4_FRAGMENT_entry.PrevPtr], edi	464	cmp [esi + IPv4_FRAGMENT_entry.PrevPtr], edi
469	jne .destroy_slot_pop ; Damn, something screwed up, remove the whole slot (and free buffers too if possible!)	465	jne .destroy_slot_pop ; Damn, something screwed up, remove the whole slot (and free buffers too if possible!)
470	mov cx, [esi + sizeof.IPv4_FRAGMENT_entry + IPv4_header.TotalLength] ; Add total length	466	mov cx, [esi + sizeof.IPv4_FRAGMENT_entry + IPv4_header.TotalLength] ; Add total length
471	xchg cl, ch	467	xchg cl, ch
472	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Packet size=%u\n", cx	468	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Packet size=%u\n", cx
473	add ax, cx	469	add ax, cx
474	movzx cx, [esi + sizeof.IPv4_FRAGMENT_entry + IPv4_header.VersionAndIHL] ; Sub Header length	470	movzx cx, [esi + sizeof.IPv4_FRAGMENT_entry + IPv4_header.VersionAndIHL] ; Sub Header length
475	and cx, 0x000F	471	and cx, 0x000F
476	shl cx, 2	472	shl cx, 2
477	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Header size=%u\n", cx	473	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Header size=%u\n", cx
478	sub ax, cx	474	sub ax, cx
479	mov edi, esi	475	mov edi, esi
480	mov esi, [esi + IPv4_FRAGMENT_entry.NextPtr]	476	mov esi, [esi + IPv4_FRAGMENT_entry.NextPtr]
481	cmp esi, -1	477	cmp esi, -1
482	jne .count_bytes	478	jne .count_bytes
483		479
484	mov esi, [esp+4]	480	mov esi, [esp+4]
485	mov [edi + IPv4_FRAGMENT_entry.NextPtr], esi ; Add this packet to the chain, this simplifies the following code	481	mov [edi + IPv4_FRAGMENT_entry.NextPtr], esi ; Add this packet to the chain, this simplifies the following code
486	mov [esi + IPv4_FRAGMENT_entry.NextPtr], -1	482	mov [esi + IPv4_FRAGMENT_entry.NextPtr], -1
487	mov [esi + IPv4_FRAGMENT_entry.PrevPtr], edi	483	mov [esi + IPv4_FRAGMENT_entry.PrevPtr], edi
488	mov [esi + IPv4_FRAGMENT_entry.Owner], ebx	484	mov [esi + IPv4_FRAGMENT_entry.Owner], ebx
489		485
490	mov cx, [edx + IPv4_header.TotalLength] ; Note: This time we dont substract Header length	486	mov cx, [edx + IPv4_header.TotalLength] ; Note: This time we dont substract Header length
491	xchg cl, ch	487	xchg cl, ch
492	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Packet size=%u\n", cx	488	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Packet size=%u\n", cx
493	add ax, cx	489	add ax, cx
494	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Total Received data size=%u\n", eax	490	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Total Received data size=%u\n", eax

Subversion Repositories Kolibri OS

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