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

 ;;          GNU GENERAL PUBLIC LICENSE                             ;;
 ;;             Version 2, June 1991                                ;;
 ;;                                                                 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 5584 $
+$Revision: 5842 $
 IPv4_MAX_FRAGMENTS              = 64
 ;  and call appropriate handler. (TCP/UDP/ICMP/..)
+;
 ;  It will also re-construct fragmented packets
+;
 ;  IN:  Pointer to buffer in [esp]
-;       size of buffer in [esp+4]
 ;       pointer to device struct in ebx
 ;       pointer to IPv4 header in edx
 ;       size of IPv4 packet in ecx
 ;  OUT: /
+;
 ;-----------------------------------------------------------------
 align 4
-IPv4_input:                                                     ; TODO: add IPv4 raw sockets support
+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
-        [edx + IPv4_header.DestinationAddress + 2]:1,[edx + IPv4_header.DestinationAddress + 3]: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 is correct
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_input: Checksum ok\n"
-        call    NET_ptr_to_num4
+;--------------------------------
+; Check if destination IP matches
-        ; check if it matches local ip (Using RFC1122 strong end system model)
-        mov     eax, [edx + IPv4_header.DestinationAddress]
+; local ip (Using RFC1122 strong end system model)
-        cmp     eax, [IP_LIST + edi]
+        mov     eax, [edx + IPv4_header.DestinationAddress]
-        je      .ip_ok
         cmp     eax, [IP_LIST + edi]
-        ; check for broadcast (IP or (not SUBNET))
+        je      .ip_ok
-        cmp     eax, [BROADCAST_LIST + edi]
-        je      .ip_ok
+; network layer broadcast
         cmp     eax, [BROADCAST_LIST + edi]
-        ; or a special broadcast (255.255.255.255)
+        je      .ip_ok
-        cmp     eax, 0xffffffff
-        je      .ip_ok
+; physical layer broadcast (255.255.255.255)
         cmp     eax, 0xffffffff
-        ; maybe it's a multicast (224.0.0.0/4)
+        je      .ip_ok
         and     eax, 0x0fffffff
-        cmp     eax, 224
+; multicast (224.0.0.0/4 = 224.0.0.0 to 239.255.255.255)
-        je      .ip_ok
+        and     eax, 0x0fffffff
         cmp     eax, 224
         movzx   ecx, [edx + IPv4_header.TotalLength]            ; Calculate length of encapsulated Packet
         xchg    cl, ch                                          ;
-        sub     ecx, esi                                        ;
         sub     ecx, esi                                        ;
         lea     edi, [edx + IPv4_header.SourceAddress]          ; make edi ptr to source and dest IPv4 address
         mov     al, [edx + IPv4_header.Protocol]
         add     esi, edx                                        ; make esi ptr to data
         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
-        je      ICMP_input
+        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
   .dump:
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_input: dumping\n"
+  .invalid_device:
-        inc     [IPv4_packets_dumped]                           ; FIXME: use correct interface
+        DEBUGF  DEBUG_NETWORK_ERROR, "IPv4_input: packet originated from invalid device\n"
 ;------------------------------------------------------------------
+;
 ; IPv4_output
 ;
+; IN:    al = protocol
-; IN:   eax = Destination IP
+;        ah = TTL
 ;       ebx = device ptr (or 0 to let IP layer decide)
 ;       ecx = data length
 ;       edx = Source IP
-;        di = TTL shl 8 + protocol
+;       edi = Destination IP
+;
 ; OUT:  eax = pointer to buffer start / 0 on error
 ;       ebx = device ptr (send packet through this device)
 ;       ecx = data length
         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
-        push    ecx di eax
+        mov     eax, edi
         call    IPv4_route              ; outputs device number in edi, dest ip in eax, source IP in edx
         push    edx
         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: ARP error=%x\n", eax
+        DEBUGF  DEBUG_NETWORK_ERROR, "IPv4_output: ip=0x%x\n", eax
-        add     esp, 3*4+2
+        add     esp, 4+2
         xor     eax, eax
         ret
 align 4
 IPv4_output_raw:
-        DEBUGF 1,"IPv4_output_raw: size=%u ptr=%x socket=%x\n", ecx, esi, eax
-        cmp     ecx, 1480               ;;;;; FIXME
-        ja      .too_large
+        DEBUGF 1,"IPv4_output_raw: size=%u ptr=%x socket=%x\n", ecx, esi, eax
         sub     esp, 8
         push    esi eax
         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
+;; TODO: check socket options if we should add header, or just compute checksum
         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
         add     esp, 6
   .arp_error:
-        add     esp, 8+4+4
-  .too_large:
+        add     esp, 8+4+4
-        DEBUGF  DEBUG_NETWORK_ERROR, "IPv4_output_raw: Failed\n"
+        mov     ebx, ENOTCONN
         or      eax, -1
         ret
 ;--------------------------------------------------------
 ;
 ;
-; IN: dword [esp] = pointer to buffer containing ipv4 packet to be fragmented
+; IN: [esp] = pointer to buffer containing ipv4 packet to be fragmented
-;     esi = pointer to ip header in that buffer
+;     edi = pointer to ip header in that buffer
-;     ecx = max size of fragments
+;     ebx = device ptr
+;
+; OUT: /
-; OUT: /
+;
+;--------------------------------------------------------
+proc IPv4_fragment stdcall buffer
+locals
+        offset          dd ?
-;
+        headerlength    dd ?
+        headerptr       dd ?
-;--------------------------------------------------------
+        dataptr         dd ?
+        remaining       dd ?
-align 4
-IPv4_fragment:
+        segmentsize     dd ?
+endl
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_fragment\n"
-        and     ecx, not 111b   ; align 4
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_fragment\n"
-        cmp     ecx, sizeof.IPv4_header + 8     ; must be able to put at least 8 bytes
-        jb      .err2
+; We must be able to put at least 8 bytes per segment
+        movzx   eax, byte[edi]          ; IHL
-        push    esi ecx
-        mov     eax, [esi + IPv4_header.DestinationAddress]
+        and     eax, 0xf
-        call    ARP_IP_to_MAC
+        shl     eax, 2
-        pop     ecx esi
-        cmp     eax, -1
+        mov     [headerlength], eax
-        jz      .err2
+        add     eax, 8
+        mov     ecx, [ebx + NET_DEVICE.mtu]
+        and     ecx, not 11b
+        cmp     ecx, eax
+        jb      .fail
+        mov     [edi + IPv4_header.HeaderChecksum], 0
-        push    ebx
-        push    ax
+        mov     [segmentsize], ecx
-        mov     ebx, [NET_DRV_LIST]
+        mov     [headerptr], edi
-        lea     eax, [ebx + ETH_DEVICE.mac]
+        movzx   ecx, [edi + IPv4_header.TotalLength]
+        xchg    cl, ch
+        sub     ecx, [headerlength]
+        mov     [remaining], ecx
+        mov     [offset], 0
+        add     edi, [headerlength]
-        push    eax
+        mov     [dataptr], edi
+  .loop:
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "Ipv4_fragment: new fragment"
-        push    esi                             ; ptr to ip header
+        mov     ecx, [segmentsize]
+        cmp     ecx, [remaining]
+        jbe     @f
+        mov     ecx, [remaining]
-        sub     ecx, sizeof.IPv4_header         ; substract header size
+  @@:
-        push    ecx                             ; max data size
-        push    dword 0                         ; offset
+        mov     ax, ETHER_PROTO_IPv4
+        mov     edx, [esp]
         add     edx, [edx + NET_BUFF.offset]
-  .new_fragment:
+;        add     edx, ETH_header.DstMAC         ; = 0
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "Ipv4_fragment: new fragment"
+        call    ETH_output
+        jz      .fail
-        mov     ax, ETHER_PROTO_IPv4
-        lea     ebx, [esp + 4*4]
-        call    ETH_output
+        push    edi
-        jz      .err
+        mov     edx, ecx
+; copy header
-; copy header
+        mov     esi, [headerptr]
-        mov     esi, [esp + 2*4]
+        mov     ecx, [headerlength]
-        mov     ecx, 5  ; 5 dwords: TODO: use IHL field of the header!
-        rep movsd
+        shr     ecx, 2
-; copy data
-        mov     esi, [esp + 2*4]
-        add     esi, sizeof.IPv4_header
+        rep movsd
-        add     esi, [esp]      ; offset
-        mov     ecx, [esp + 1*4]
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "IPv4_fragment: copying %u bytes\n", ecx
-        rep movsb
+; copy data
-; now, correct header
+        mov     esi, [dataptr]
+        add     esi, [offset]
+        mov     ecx, edx
+        sub     ecx, [headerlength]
+        shr     ecx, 2
+        rep movsd
-        mov     ecx, [esp + 1*4]
+        pop     edi
-        add     ecx, sizeof.IPv4_header
+; now, correct header
+; packet length
-        xchg    cl, ch
+        mov     ax, dx
-        mov     [edi + IPv4_header.TotalLength], cx
+        xchg    al, ah
-        mov     ecx, [esp]              ; offset
+        mov     [edi + IPv4_header.TotalLength], ax
-        xchg    cl, ch
-;        cmp     dword[esp + 4*4], 0     ; last fragment?;<<<<<<
-;        je      .last_fragment
-        or      cx, 1 shl 2             ; more fragments
-;  .last_fragment:
-        mov     [edi + IPv4_header.FlagsAndFragmentOffset], cx
+; offset
-        mov     [edi + IPv4_header.HeaderChecksum], 0
-        ;<<<<<<<<<<<<<<<<<<<<<<<<<<<<< send the packet
-        mov     ecx, [esp + 1*4]
+        mov     eax, [offset]
-        push    edx eax
-        IPv4_checksum edi
+        xchg    al, ah
-        call    [ebx + NET_DEVICE.transmit]
+        sub     edx, [headerlength]
-        ;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
-        mov     ecx, [esp+4]
-        add     [esp], ecx
         sub     [remaining], edx
-        mov     ecx, [esp+3*4+6+4]      ; ptr to begin of buff
+        je      @f
+        jb      .fail
+        or      ah, 1 shl 2             ; more fragments
-        add     ecx, [esp+3*4+6+4+4]    ; buff size
+        add     [offset], edx
-        sub     ecx, [esp+2*4]          ; ptr to ip header
+  @@:
-        add     ecx, [esp]              ; offset
+        mov     [edi + IPv4_header.FlagsAndFragmentOffset], ax
 ; Fill in remote IP
         pushd   [edx + 4]
-        pop     [eax + IP_SOCKET.RemoteIP]
-; Set up data receiving queue
-        push    eax
-        init_queue (eax + SOCKET_QUEUE_LOCATION)
-        pop     eax
+        pop     [eax + IP_SOCKET.RemoteIP]
         lea     ecx, [eax + SOCKET.mutex]
         call    mutex_unlock

Subversion Repositories Kolibri OS

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