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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2022. 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: 9817 $
 
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
 
        IPv4_address            rd NET_DEVICES_MAX
        IPv4_subnet             rd NET_DEVICES_MAX
        IPv4_nameserver         rd NET_DEVICES_MAX
        IPv4_gateway            rd NET_DEVICES_MAX
        IPv4_broadcast          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_fragments          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, IPv4_address
        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_fragments
        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, [IPv4_address + edi]
        je      .ip_ok
 
; network layer broadcast
        cmp     eax, [IPv4_broadcast + 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     [IPv4_address + 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 + sizeof.NET_BUFF + 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 + sizeof.NET_BUFF + 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 + sizeof.NET_BUFF + IPv4_FRAGMENT_entry.NextPtr], eax        ; update pointer of previous entry to the new entry
        mov     [eax + sizeof.NET_BUFF + IPv4_FRAGMENT_entry.NextPtr], -1
        mov     [eax + sizeof.NET_BUFF + IPv4_FRAGMENT_entry.PrevPtr], edi
        mov     [eax + sizeof.NET_BUFF + 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_fragments
  .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 + sizeof.NET_BUFF + IPv4_FRAGMENT_entry.NextPtr], -1
        mov     [eax + sizeof.NET_BUFF + IPv4_FRAGMENT_entry.PrevPtr], -1
        mov     [eax + sizeof.NET_BUFF + 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                                                     ; Save pointer to first buffer on stack
        push    edi                                                     ; Save device index on stack
        xor     eax, eax
        or      edi, -1
 
  .count_bytes:
        cmp     [esi + sizeof.NET_BUFF + 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.NET_BUFF + 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.NET_BUFF + 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 + sizeof.NET_BUFF + IPv4_FRAGMENT_entry.NextPtr]
        cmp     esi, -1
        jne     .count_bytes
 
        mov     esi, [esp+8]                                                                              ; Take the current (last) buffer pointer
        mov     [edi + sizeof.NET_BUFF + IPv4_FRAGMENT_entry.NextPtr], esi                                ; Add this packet to the chain, this simplifies the following code
        mov     [esi + sizeof.NET_BUFF + IPv4_FRAGMENT_entry.NextPtr], -1
        mov     [esi + sizeof.NET_BUFF + IPv4_FRAGMENT_entry.PrevPtr], edi
        mov     [esi + sizeof.NET_BUFF + 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                                                                     ; Save total size of packet on stack
        push    eax
        call    kernel_alloc
        test    eax, eax
        je      .destroy_slot_pop12                                                     ; If we dont have enough space to allocate the buffer, discard all packets in slot
        mov     edx, [esp+8]                                                            ; Get pointer to first fragment entry back in edx
 
        ; FIXME: Allocate NET_BUFF here instead of raw IP packet buffer
 
  .rebuild_packet_loop:
        movzx   ecx, [edx + sizeof.NET_BUFF + 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.NET_BUFF + sizeof.IPv4_FRAGMENT_entry + IPv4_header.VersionAndIHL]     ; Find header size (in ebx) of fragment
        and     bx, 0x000F                                                              ;
        shl     bx, 2                                                                   ;
 
        lea     esi, [edx + sizeof.NET_BUFF + sizeof.IPv4_FRAGMENT_entry]                                 ; Set esi to the correct begin of fragment
        movzx   ecx, [edx + sizeof.NET_BUFF + 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                                                                ;
        add     edi, ebx                                                                ; FIXME: We should add size of header of first fragment here
                                                                                        ; instead of size of currently copying fragment
                                                                                        ; because the fragment offset is offset within the big IP packet
                                                                                        ; data (not within the packet, within packet's contents)
  .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 + sizeof.NET_BUFF + IPv4_FRAGMENT_entry.Owner]                                       ; we need to remeber the owner, in case this is the last packet
        push    [edx + sizeof.NET_BUFF + 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                     ; Restore the total size of IP packet
        pop     edi                     ; Restore the device index
        xchg    cl, ch
        mov     edx, eax
        mov     [edx + IPv4_header.TotalLength], cx
        add     esp, 8                  ; Remove pointer to first buffer and pointer to last buffer from the stack
        xchg    cl, ch
        push    edx                     ; Push pointer to the new buffer with full IP packet
 
; FIXME: Remove this block once allocated network buffers handling is implemented.
if 1
        DEBUGF  DEBUG_NETWORK_ERROR, "IPv4_input: fragmented packet of size %d is dropped\n", ecx
        call    kernel_free             ; Ptr to buffer is on the stack already
        inc     [IPv4_packets_dumped + edi]
        ret
end if
 
        jmp     .handle_it              ; edx = buf ptr, ecx = size, [esp] buf ptr, ebx=device ptr
 
  .destroy_slot_pop12:
        add     esp, 4 ; Remove total size from the stack
  .destroy_slot_pop:
        pop     edi    ; Restore device index
        add     esp, 4 ; Remove first buffer pointer from the stack
  .destroy_slot:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_input: Destroy fragment slot!\n"
        ; TODO: What?
        ; Last buffer pointer is on the stack now
        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_fragments
        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, edi
 
        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
        test    eax, eax
        jz      .no_route
        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_device_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
 
  .no_route:
        DEBUGF  DEBUG_NETWORK_ERROR, "IPv4_output: No route to host!\n"
        add     esp, 2*4+2
        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:
        inc     [IPv4_packets_tx + edi]                 ; update stats
 
        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_device_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 (may be gateway), 0 on error         ;
;       edx = Source IP                                           ;
;       edi = device number*4                                     ;
;                                                                 ;
; DESTROYED:                                                      ;
;       ecx                                                       ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
ipv4_route:
 
        test    ebx, ebx
        jnz     .got_device
 
; Broadcast does not need gateway
        cmp     eax, 0xffffffff
        je      .broadcast
 
        xor     edi, edi
  .loop:
        mov     ebx, [IPv4_address + edi]
        and     ebx, [IPv4_subnet + edi]
        jz      .next
        mov     ecx, eax
        and     ecx, [IPv4_subnet + edi]
        cmp     ebx, ecx
        je      .got_it
  .next:
        add     edi, 4
        cmp     edi, 4*NET_DEVICES_MAX
        jb      .loop
 
        mov     eax, [IPv4_gateway + 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, [IPv4_address + edi]
  @@:
 
        ret
 
  .got_device:
; Validate device ptr and convert to device number
        call    net_ptr_to_num4
        cmp     edi, -1
        je      .fail
 
        mov     edx, [IPv4_address + edi]            ; Source IP
 
; Broadcast does not need gateway
        cmp     eax, 0xffffffff
        je      @f
 
; Check if we should route to gateway or not
        mov     ebx, [IPv4_address + edi]
        and     ebx, [IPv4_subnet + edi]
        mov     ecx, eax
        and     ecx, [IPv4_subnet + edi]
        cmp     ecx, ebx
        je      @f
        mov     eax, [IPv4_gateway + edi]
  @@:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_route: %u\n", edi
        ret
 
  .fail:
        DEBUGF  DEBUG_NETWORK_ERROR, "IPv4_route failed\n"
        xor     eax, eax
        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    [IPv4_address + 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, [IPv4_address + eax]
        ret
 
  .write_ip:
        mov     [IPv4_address + eax], ecx
        mov     edi, eax                        ; device number, we'll need it for ARP
 
        ; pre-calculate the local broadcast address
        mov     ebx, [IPv4_subnet + eax]
        not     ebx
        or      ebx, ecx
        mov     [IPv4_broadcast + eax], ebx
 
        mov     ebx, [net_device_list + eax]
        mov     eax, [IPv4_address + eax]
        call    arp_output_request              ; now send a gratuitous ARP
 
        call    net_send_event
        xor     eax, eax
        ret
 
  .read_dns:
        mov     eax, [IPv4_nameserver + eax]
        ret
 
  .write_dns:
        mov     [IPv4_nameserver + eax], ecx
        call    net_send_event
        xor     eax, eax
        ret
 
  .read_subnet:
        mov     eax, [IPv4_subnet + eax]
        ret
 
  .write_subnet:
        mov     [IPv4_subnet + eax], ecx
 
        ; pre-calculate the local broadcast address
        mov     ebx, [IPv4_address + eax]
        not     ecx
        or      ecx, ebx
        mov     [IPv4_broadcast + eax], ecx
 
        call    net_send_event
        xor     eax, eax
        ret
 
  .read_gateway:
        mov     eax, [IPv4_gateway + eax]
        ret
 
  .write_gateway:
        mov     [IPv4_gateway + eax], ecx
 
        call    net_send_event
        xor     eax, eax
        ret

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/network/IPv4.inc @ 6011 – Rev 9815 → 9817