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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2015. All rights reserved.    ;;
;; Distributed under terms of the GNU General Public License       ;;
;;                                                                 ;;
;;  ARP.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: 5522 $
 
ARP_NO_ENTRY            = 0
ARP_VALID_MAPPING       = 1
ARP_AWAITING_RESPONSE   = 2
ARP_RESPONSE_TIMEOUT    = 3
 
ARP_REQUEST_TTL         = 31          ; 20 s
ARP_ENTRY_TTL           = 937         ; 600 s
ARP_STATIC_ENTRY        = -1
 
ARP_REQ_OPCODE          = 0x0100      ; request
ARP_REP_OPCODE          = 0x0200      ; reply
 
ARP_TABLE_SIZE          = 20          ; Size of table
 
struct  ARP_entry
 
        IP              dd ?
        MAC             dp ?
        Status          dw ?
        TTL             dw ?
 
ends
 
struct  ARP_header
 
        HardwareType    dw ?
        ProtocolType    dw ?
        HardwareSize    db ?
        ProtocolSize    db ?
        Opcode          dw ?
        SenderMAC       dp ?
        SenderIP        dd ?
        TargetMAC       dp ?
        TargetIP        dd ?
 
ends
 
uglobal
align 4
 
        ARP_table       rb NET_DEVICES_MAX*(ARP_TABLE_SIZE * sizeof.ARP_entry)
 
        ARP_entries_num rd NET_DEVICES_MAX
        ARP_PACKETS_TX  rd NET_DEVICES_MAX
        ARP_PACKETS_RX  rd NET_DEVICES_MAX
        ARP_CONFLICTS   rd NET_DEVICES_MAX
 
 
endg
 
 
 
 
 
 
;-----------------------------------------------------------------;
;                                                                 ;
 
; arp_init: Resets all ARP variables.                             ;
;                                                                 ;
;-----------------------------------------------------------------;
macro arp_init {
 
        xor     eax, eax
        mov     edi, ARP_entries_num
        mov     ecx, 4*NET_DEVICES_MAX
        rep stosd
 
}
 
 
;-----------------------------------------------------------------;
;                                                                 ;
 
; arp_decrease_entry_ttls                                         ;
;                                                                 ;
 
;-----------------------------------------------------------------;
macro arp_decrease_entry_ttls {
 
local   .loop
local   .exit
 
; The TTL field is decremented every second, and is deleted when it reaches 0.
; It is refreshed every time a packet is received.
; If the TTL field is 0xFFFF it is a static entry and is never deleted.
; The status field can be the following values:
; 0x0000  entry not used
; 0x0001  entry holds a valid mapping
; 0x0002  entry contains an IP address, awaiting ARP response
; 0x0003  No response received to ARP request.
; The last status value is provided to allow the network layer to delete
; a packet that is queued awaiting an ARP response
 
        xor     edi, edi
  .loop_outer:
        mov     ecx, [ARP_entries_num + 4*edi]
        test    ecx, ecx
        jz      .exit
 
        mov     esi, (ARP_TABLE_SIZE * sizeof.ARP_entry)
        imul    esi, edi
        add     esi, ARP_table
  .loop:
        cmp     [esi + ARP_entry.TTL], ARP_STATIC_ENTRY
        je      .next
 
        dec     [esi + ARP_entry.TTL]
        jz      .time_out
 
  .next:
        add     esi, sizeof.ARP_entry
        dec     ecx
        jnz     .loop
        jmp     .exit
 
  .time_out:
        cmp     [esi + ARP_entry.Status], ARP_AWAITING_RESPONSE
        je      .response_timeout
 
        push    esi edi ecx
        call    arp_del_entry
        pop     ecx edi esi
 
        jmp     .next
 
  .response_timeout:
        mov     [esi + ARP_entry.Status], ARP_RESPONSE_TIMEOUT
        mov     [esi + ARP_entry.TTL], 10
 
        jmp     .next
 
  .exit:
        inc     edi
        cmp     edi, NET_DEVICES_MAX
        jb      .loop_outer
 
}
 
 
 
;-----------------------------------------------------------------;
;                                                                 ;
 
; arp_input                                                       ;
;                                                                 ;
;  IN:  [esp] = Pointer to buffer                                 ;
;       [esp+4] = size of buffer                                  ;
;       ecx = packet size (without ethernet header)               ;
;       edx = packet ptr                                          ;
;       ebx = device ptr                                          ;
;                                                                 ;
 
;  OUT: /                                                         ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
arp_input:
 
;-----------------------------------------
; Check validity and print some debug info
 
        cmp     ecx, sizeof.ARP_header
        jb      .exit
 
        call    net_ptr_to_num4
        cmp     edi, -1
        jz      .exit
 
        inc     [ARP_PACKETS_RX + edi]          ; update stats
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "ARP_input: got packet from %u.%u.%u.%u (device*4=%u)\n",\
        [edx + ARP_header.SenderIP]:1, [edx + ARP_header.SenderIP + 1]:1,\
        [edx + ARP_header.SenderIP + 2]:1, [edx + ARP_header.SenderIP + 3]:1, edi
 
;------------------------------
; First, check for IP collision
 
        mov     eax, [edx + ARP_header.SenderIP]
        cmp     eax, [IP_LIST + edi]
        je      .collision
 
;---------------------
; Handle reply packets
 
        cmp     [edx + ARP_header.Opcode], ARP_REP_OPCODE
        jne     .maybe_request
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "ARP_input: It's a reply\n"
 
        mov     ecx, [ARP_entries_num + edi]
        test    ecx, ecx
        jz      .exit
 
        mov     esi, edi
        imul    esi, (ARP_TABLE_SIZE * sizeof.ARP_entry)/4
        add     esi, ARP_table
  .loop:
        cmp     [esi + ARP_entry.IP], eax
        je      .gotit
        add     esi, sizeof.ARP_entry
        dec     ecx
        jnz     .loop
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "ARP_input: no matching entry found\n"
        jmp     .exit
 
  .gotit:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "ARP_input: found matching entry\n"
 
        cmp     [esi + ARP_entry.TTL], ARP_STATIC_ENTRY         ; if it is a static entry, dont touch it
        je      .exit
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "ARP_input: updating entry\n"
 
        mov     [esi + ARP_entry.Status], ARP_VALID_MAPPING
        mov     [esi + ARP_entry.TTL], ARP_ENTRY_TTL
 
        mov     eax, dword [edx + ARP_header.SenderMAC]
        mov     dword [esi + ARP_entry.MAC], eax
        mov     cx, word [edx + ARP_header.SenderMAC + 4]
        mov     word [esi + ARP_entry.MAC + 4], cx
 
        jmp     .exit
 
;-----------------------
; Handle request packets
 
  .maybe_request:
        cmp     [edx + ARP_header.Opcode], ARP_REQ_OPCODE
        jne     .exit
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "ARP_input: its a request\n"
 
        mov     eax, [IP_LIST + edi]
        cmp     eax, [edx + ARP_header.TargetIP]                ; Is it looking for my IP address?
        jne     .exit
 
        push    eax
        push    edi
 
; OK, it is a request for one of our MAC addresses.
; Build the frame and send it. We can reuse the buffer.  (faster then using ARP_create_packet)
 
        lea     esi, [edx + ARP_header.SenderMAC]
        lea     edi, [edx + ARP_header.TargetMAC]
        movsd                                                   ; Move Sender Mac to Dest MAC
        movsw                                                   ;
        movsd                                                   ; Move sender IP to Dest IP
 
        pop     esi
        mov     esi, [NET_DRV_LIST + esi]
        lea     esi, [esi + ETH_DEVICE.mac]
        lea     edi, [edx + ARP_header.SenderMAC]
        movsd                                                   ; Copy MAC address from in MAC_LIST
        movsw                                                   ;
        pop     eax
        stosd                                                   ; Write our IP
 
        mov     [edx + ARP_header.Opcode], ARP_REP_OPCODE
 
; Now, Fill in ETHERNET header
 
        mov     edi, [esp]
        lea     esi, [edx + ARP_header.TargetMAC]
        movsd
        movsw
        lea     esi, [edx + ARP_header.SenderMAC]
        movsd
        movsw
;        mov     ax , ETHER_ARP                                 ; It's already there, I'm sure of it!
;        stosw
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "ARP_input: Sending reply\n"
 
        call    [ebx + NET_DEVICE.transmit]
        ret
 
  .collision:
        inc     [ARP_CONFLICTS + edi]
        DEBUGF  DEBUG_NETWORK_VERBOSE, "ARP_input: IP address conflict detected!\n"
 
  .exit:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "ARP_input: exiting\n"
        call    net_buff_free
        ret
 
 
;-----------------------------------------------------------------;
;                                                                 ;
 
; arp_output_request                                              ;
;                                                                 ;
;  IN:  ebx = device ptr                                          ;
 
;       eax = IP                                                  ;
;                                                                 ;
 
; OUT:  scratched: probably everything                            ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
arp_output_request:
 
        push    eax
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "ARP_output_request: ip=%u.%u.%u.%u device=0x%x\n",\
        [esp]:1, [esp + 1]:1, [esp + 2]:1, [esp + 3]:1, ebx
 
        mov     ax, ETHER_PROTO_ARP
        mov     ecx, sizeof.ARP_header
        mov     edx, ETH_BROADCAST              ; broadcast mac
        call    eth_output
        jz      .exit
 
        mov     [edi + ARP_header.HardwareType], 0x0100         ; Ethernet
        mov     [edi + ARP_header.ProtocolType], 0x0008         ; IP
        mov     [edi + ARP_header.HardwareSize], 6              ; MAC-addr length
        mov     [edi + ARP_header.ProtocolSize], 4              ; IP-addr length
        mov     [edi + ARP_header.Opcode], ARP_REQ_OPCODE       ; Request
 
        add     edi, ARP_header.SenderMAC
        lea     esi, [ebx + ETH_DEVICE.mac]     ; SenderMac
        movsw                                   ;
        movsd                                   ;
 
        push    edi
        call    net_ptr_to_num4
        inc     [ARP_PACKETS_TX + edi]          ; assume we will succeed
        lea     esi, [IP_LIST + edi]            ; SenderIP
        pop     edi
        movsd
 
        mov     esi, ETH_BROADCAST              ; DestMac
        movsw                                   ;
        movsd                                   ;
        popd    [edi]                           ; DestIP
 
        push    eax
        call    [ebx + NET_DEVICE.transmit]
        ret
 
  .exit:
        add     esp, 4
        DEBUGF  DEBUG_NETWORK_ERROR, "ARP_output_request: send failed\n"
        ret
 
 
 
;-----------------------------------------------------------------;
;                                                                 ;
 
; arp_add_entry: Add or update an entry in the ARP table.         ;
;                                                                 ;
;  IN:  esi = ptr to entry (can easily be made on the stack)      ;
;       edi = device num*4                                        ;
;                                                                 ;
; OUT:  eax = entry number on success                             ;
;       eax = -1 on error                                         ;
 
;       esi = ptr to newly created entry                          ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
arp_add_entry:
 
; TODO: use a mutex to lock ARP table
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "ARP_add_entry: device=%u\n", edi
 
        mov     ecx, [ARP_entries_num + edi]
        cmp     ecx, ARP_TABLE_SIZE                                     ; list full ?
        jae     .full
 
; From this point on, we can only fail if IP has a static entry, or if table is corrupt.
 
        inc     [ARP_entries_num + edi]                                 ; assume we will succeed
 
        push    edi
        xor     ecx, ecx
        imul    edi, ARP_TABLE_SIZE*sizeof.ARP_entry/4
        add     edi, ARP_table
        mov     eax, [esi + ARP_entry.IP]
  .loop:
        cmp     [edi + ARP_entry.Status], ARP_NO_ENTRY                  ; is this slot empty?
        je      .add
 
        cmp     [edi + ARP_entry.IP], eax                               ; if not, check if it doesnt collide
        jne     .maybe_next
 
        cmp     [edi + ARP_entry.TTL], ARP_STATIC_ENTRY                 ; ok, its the same IP, update it if not static
        jne     .add
 
        DEBUGF  DEBUG_NETWORK_ERROR, "ARP_add_entry: failed, IP already has a static entry\n"
        jmp     .error
 
  .maybe_next:                                                          ; try the next slot
        add     edi, sizeof.ARP_entry
        inc     ecx
        cmp     ecx, ARP_TABLE_SIZE
        jb      .loop
 
  .add:
        push    ecx
        mov     ecx, sizeof.ARP_entry/2
        rep movsw
        pop     ecx
        lea     esi, [edi - sizeof.ARP_entry]
        pop     edi
        DEBUGF  DEBUG_NETWORK_VERBOSE, "ARP_add_entry: entry=%u\n", ecx
 
        ret
 
  .error:
        pop     edi
        dec     [ARP_entries_num + edi]
        DEBUGF  DEBUG_NETWORK_ERROR, "ARP_add_entry_failed\n"
  .full:
        mov     eax, -1
        ret
 
 
 
;-----------------------------------------------------------------;
;                                                                 ;
 
; arp_del_entry: Remove an entry from the ARP table.              ;
;                                                                 ;
; IN:   esi = ptr to arp entry                                    ;
;       edi = device number                                       ;
;                                                                 ;
 
; OUT:  /                                                         ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
arp_del_entry:
 
; TODO: use a mutex to lock ARP table
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "ARP_del_entry: entry=0x%x entrys=%u\n", esi, [ARP_entries_num + 4*edi]
        DEBUGF  DEBUG_NETWORK_VERBOSE, "ARP_del_entry: IP=%u.%u.%u.%u\n", \
        [esi + ARP_entry.IP]:1, [esi + ARP_entry.IP + 1]:1, [esi + ARP_entry.IP + 2]:1, [esi + ARP_entry.IP + 3]:1
 
        push    edi
        imul    edi, (ARP_TABLE_SIZE) * sizeof.ARP_entry
        lea     ecx, [ARP_table + (ARP_TABLE_SIZE - 1) * sizeof.ARP_entry + edi]
        sub     ecx, esi
        shr     ecx, 1
 
; move all trailing entries, sizeof.ARP_entry bytes to left.
        mov     edi, esi
        add     esi, sizeof.ARP_entry
        rep movsw
 
; now add an empty entry to the end (erasing previous one)
        xor     eax, eax
        mov     ecx, sizeof.ARP_entry/2
        rep stosw
 
        pop     edi
        dec     [ARP_entries_num + 4*edi]
        DEBUGF  DEBUG_NETWORK_VERBOSE, "ARP_del_entry: success\n"
 
        ret
 
 
 
 
 
 
;-----------------------------------------------------------------;
 
;                                                                 ;
 
; arp_ip_to_mac: Translate an IP address to a MAC address.        ;
;                                                                 ;
;  IN:  eax = IPv4 address                                        ;
;       edi = device number * 4                                   ;
;                                                                 ;
;  OUT: eax = -1 on error                                         ;
;       eax = -2 when request send                                ;
;       eax = first two bytes of mac on success                   ;
;       ebx = last four bytes of mac on success                   ;
 
;       edi = unchanged                                           ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
arp_ip_to_mac:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "ARP_IP_to_MAC: %u.%u", al, ah
        rol     eax, 16
        DEBUGF  DEBUG_NETWORK_VERBOSE, ".%u.%u device*4: %u\n", al, ah, edi
        rol     eax, 16
 
        cmp     eax, 0xffffffff
        je      .broadcast
 
;--------------------------------
; Try to find the IP in ARP_table
 
        mov     ecx, [ARP_entries_num + edi]
        test    ecx, ecx
        jz      .not_in_list
        mov     esi, edi
        imul    esi, (sizeof.ARP_entry * ARP_TABLE_SIZE)/4
        add     esi, ARP_table + ARP_entry.IP
  .scan_loop:
        cmp     [esi], eax
        je      .found_it
        add     esi, sizeof.ARP_entry
        dec     ecx
        jnz     .scan_loop
 
  .not_in_list:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "ARP_IP_to_MAC: preparing for ARP request\n"
 
        push    eax edi                 ; save IP for ARP_output_request
; Now craft the ARP entry on the stack
        pushw   ARP_REQUEST_TTL         ; TTL
        pushw   ARP_AWAITING_RESPONSE   ; status
        pushd   0                       ; mac
        pushw   0
        pushd   eax                     ; IP
        mov     esi, esp
 
; Add it to the list
        call    arp_add_entry
 
; Delete the temporary entry
        add     esp, sizeof.ARP_entry   ; clear the entry from stack
 
; If we could not add it to the list, give up
        cmp     eax, -1                 ; did ARP_add_entry fail?
        je      .full
 
;-----------------------------------------------
; At this point, we got an ARP entry in the list
 
; Now send a request packet on the network
        pop     edi eax                 ; IP in eax, device number in ebx, for ARP_output_request
 
        push    esi edi
        mov     ebx, [NET_DRV_LIST + edi]
        call    arp_output_request
        pop     edi esi
  .found_it:
        cmp     [esi + ARP_entry.Status], ARP_VALID_MAPPING             ; Does it have a MAC assigned?
        je      .valid
 
if ARP_BLOCK
 
        cmp     [esi + ARP_entry.Status], ARP_AWAITING_RESPONSE         ; Are we waiting for reply from remote end?
        jne     .give_up
        push    esi
        mov     esi, 10                 ; wait 10 ms
        call    delay_ms
        pop     esi
        jmp     .found_it               ; now check again
 
else
 
        jmp     .give_up
 
end if
 
  .valid:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "ARP_IP_to_MAC: found MAC\n"
        movzx   eax, word[esi + ARP_entry.MAC]
        mov     ebx, dword[esi + ARP_entry.MAC + 2]
        ret
 
  .full:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "ARP_IP_to_MAC: table is full!\n"
        add     esp, 8
  .give_up:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "ARP_IP_to_MAC: entry has no valid mapping!\n"
        mov     eax, -1
        ret
 
  .broadcast:
        mov     eax, 0x0000ffff
        mov     ebx, 0xffffffff
        ret
 
 
 
 
 
;-----------------------------------------------------------------;
;                                                                 ;
 
; arp_api: Part of system function 76.                            ;
;                                                                 ;
;  IN:  bl = subfunction number                                   ;
;       bh = device number                                        ;
 
;       ecx, edx, .. depends on subfunction                       ;
;                                                                 ;
 
; OUT:  depends on subfunction                                    ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
arp_api:
 
        movzx   eax, bh
        shl     eax, 2
 
        and     ebx, 0xff
        cmp     ebx, .number
        ja      .error
        jmp     dword [.table + 4*ebx]
 
  .table:
        dd      .packets_tx     ; 0
        dd      .packets_rx     ; 1
        dd      .entries        ; 2
        dd      .read           ; 3
        dd      .write          ; 4
        dd      .remove         ; 5
        dd      .send_announce  ; 6
        dd      .conflicts      ; 7
  .number = ($ - .table) / 4 - 1
 
  .error:
        mov     eax, -1
        ret
 
  .packets_tx:
        mov     eax, [ARP_PACKETS_TX + eax]
        ret
 
  .packets_rx:
        mov     eax, [ARP_PACKETS_RX + eax]
        ret
 
  .conflicts:
        mov     eax, [ARP_CONFLICTS + eax]
        ret
 
  .entries:
        mov     eax, [ARP_entries_num + eax]
        ret
 
  .read:
        cmp     ecx, [ARP_entries_num + eax]
        jae     .error
        shr     eax, 2
        imul    eax, sizeof.ARP_entry*ARP_TABLE_SIZE
        add     eax, ARP_table
        ; edi = pointer to buffer
        ; ecx = # entry
        imul    ecx, sizeof.ARP_entry
        lea     esi, [eax + ecx]
        mov     ecx, sizeof.ARP_entry/2
        rep movsw
 
        xor     eax, eax
        ret
 
  .write:
        ; esi = pointer to buffer
        mov     edi, eax
        call    arp_add_entry           ; out: eax = entry number, -1 on error
        ret
 
  .remove:
        ; ecx = # entry
        cmp     ecx, [ARP_entries_num + eax]
        jae     .error
        imul    ecx, sizeof.ARP_entry
        lea     esi, [ARP_table + ecx]
        mov     edi, eax
        shr     edi, 2
        call    arp_del_entry
        ret
 
  .send_announce:
        mov     ebx, [NET_DRV_LIST + eax]
        mov     eax, [IP_LIST + eax]
        call    arp_output_request      ; now send a gratuitous ARP
        ret

Rev 5596	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	;; ARP.INC ;;	6	;; ARP.INC ;;
7	;; ;;	7	;; ;;
8	;; Part of the tcp/ip network stack for KolibriOS ;;	8	;; Part of the tcp/ip network stack for KolibriOS ;;
9	;; ;;	9	;; ;;
10	;; Based on the work of [Johnny_B] and [smb] ;;	10	;; Based on the work of [Johnny_B] and [smb] ;;
11	;; ;;	11	;; ;;
12	;; Written by hidnplayr@kolibrios.org ;;	12	;; Written by hidnplayr@kolibrios.org ;;
13	;; ;;	13	;; ;;
14	;; GNU GENERAL PUBLIC LICENSE ;;	14	;; GNU GENERAL PUBLIC LICENSE ;;
15	;; Version 2, June- 1991 ;;	15	;; Version 2, June- 1991 ;;
16	;; ;;	16	;; ;;
17	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	17	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
18		18
19	$Revision: 5522 $	19	$Revision: 5522 $
20		20
21	ARP_NO_ENTRY = 0	21	ARP_NO_ENTRY = 0
22	ARP_VALID_MAPPING = 1	22	ARP_VALID_MAPPING = 1
23	ARP_AWAITING_RESPONSE = 2	23	ARP_AWAITING_RESPONSE = 2
24	ARP_RESPONSE_TIMEOUT = 3	24	ARP_RESPONSE_TIMEOUT = 3
25		25
26	ARP_REQUEST_TTL = 31 ; 20 s	26	ARP_REQUEST_TTL = 31 ; 20 s
27	ARP_ENTRY_TTL = 937 ; 600 s	27	ARP_ENTRY_TTL = 937 ; 600 s
28	ARP_STATIC_ENTRY = -1	28	ARP_STATIC_ENTRY = -1
29		29
30	ARP_REQ_OPCODE = 0x0100 ; request	30	ARP_REQ_OPCODE = 0x0100 ; request
31	ARP_REP_OPCODE = 0x0200 ; reply	31	ARP_REP_OPCODE = 0x0200 ; reply
32		32
33	ARP_TABLE_SIZE = 20 ; Size of table	33	ARP_TABLE_SIZE = 20 ; Size of table
34		34
35	struct ARP_entry	35	struct ARP_entry
36		36
37	IP dd ?	37	IP dd ?
38	MAC dp ?	38	MAC dp ?
39	Status dw ?	39	Status dw ?
40	TTL dw ?	40	TTL dw ?
41		41
42	ends	42	ends
43		43
44	struct ARP_header	44	struct ARP_header
45		45
46	HardwareType dw ?	46	HardwareType dw ?
47	ProtocolType dw ?	47	ProtocolType dw ?
48	HardwareSize db ?	48	HardwareSize db ?
49	ProtocolSize db ?	49	ProtocolSize db ?
50	Opcode dw ?	50	Opcode dw ?
51	SenderMAC dp ?	51	SenderMAC dp ?
52	SenderIP dd ?	52	SenderIP dd ?
53	TargetMAC dp ?	53	TargetMAC dp ?
54	TargetIP dd ?	54	TargetIP dd ?
55		55
56	ends	56	ends
57		57
58	uglobal	58	uglobal
59	align 4	59	align 4
60		60
61	ARP_table rb NET_DEVICES_MAX(ARP_TABLE_SIZE sizeof.ARP_entry)	61	ARP_table rb NET_DEVICES_MAX(ARP_TABLE_SIZE sizeof.ARP_entry)
62		62
63	ARP_entries_num rd NET_DEVICES_MAX	63	ARP_entries_num rd NET_DEVICES_MAX
64	ARP_PACKETS_TX rd NET_DEVICES_MAX	64	ARP_PACKETS_TX rd NET_DEVICES_MAX
65	ARP_PACKETS_RX rd NET_DEVICES_MAX	65	ARP_PACKETS_RX rd NET_DEVICES_MAX
66	ARP_CONFLICTS rd NET_DEVICES_MAX	66	ARP_CONFLICTS rd NET_DEVICES_MAX
67		67
68		68
69	endg	69	endg
70		70
71		71
72		72
73	;-----------------------------------------------------------------	-
74	;	-
75	; ARP_init	-
-		73	;-----------------------------------------------------------------;
76	;	74	; ;
77	; This function resets all ARP variables	-
-		75	; arp_init: Resets all ARP variables. ;
78	;	76	; ;
79	;-----------------------------------------------------------------	77	;-----------------------------------------------------------------;
80	macro ARP_init {	78	macro arp_init {
81		79
82	xor eax, eax	80	xor eax, eax
83	mov edi, ARP_entries_num	81	mov edi, ARP_entries_num
84	mov ecx, 4*NET_DEVICES_MAX	82	mov ecx, 4*NET_DEVICES_MAX
85	rep stosd	83	rep stosd
86		84
87	}	85	}
88		86
89	;---------------------------------------------------------------------------	-
-		87	;-----------------------------------------------------------------;
90	;	88	; ;
91	; ARP_decrease_entry_ttls	-
-		89	; arp_decrease_entry_ttls ;
92	;	90	; ;
93	;---------------------------------------------------------------------------	-
94		91	;-----------------------------------------------------------------;
95	macro ARP_decrease_entry_ttls {	92	macro arp_decrease_entry_ttls {
96		93
97	local .loop	94	local .loop
98	local .exit	95	local .exit
99		96
100	; The TTL field is decremented every second, and is deleted when it reaches 0.	97	; The TTL field is decremented every second, and is deleted when it reaches 0.
101	; It is refreshed every time a packet is received.	98	; It is refreshed every time a packet is received.
102	; If the TTL field is 0xFFFF it is a static entry and is never deleted.	99	; If the TTL field is 0xFFFF it is a static entry and is never deleted.
103	; The status field can be the following values:	100	; The status field can be the following values:
104	; 0x0000 entry not used	101	; 0x0000 entry not used
105	; 0x0001 entry holds a valid mapping	102	; 0x0001 entry holds a valid mapping
106	; 0x0002 entry contains an IP address, awaiting ARP response	103	; 0x0002 entry contains an IP address, awaiting ARP response
107	; 0x0003 No response received to ARP request.	104	; 0x0003 No response received to ARP request.
108	; The last status value is provided to allow the network layer to delete	105	; The last status value is provided to allow the network layer to delete
109	; a packet that is queued awaiting an ARP response	106	; a packet that is queued awaiting an ARP response
110		107
111	xor edi, edi	108	xor edi, edi
112	.loop_outer:	109	.loop_outer:
113	mov ecx, [ARP_entries_num + 4*edi]	110	mov ecx, [ARP_entries_num + 4*edi]
114	test ecx, ecx	111	test ecx, ecx
115	jz .exit	112	jz .exit
116		113
117	mov esi, (ARP_TABLE_SIZE * sizeof.ARP_entry)	114	mov esi, (ARP_TABLE_SIZE * sizeof.ARP_entry)
118	imul esi, edi	115	imul esi, edi
119	add esi, ARP_table	116	add esi, ARP_table
120	.loop:	117	.loop:
121	cmp [esi + ARP_entry.TTL], ARP_STATIC_ENTRY	118	cmp [esi + ARP_entry.TTL], ARP_STATIC_ENTRY
122	je .next	119	je .next
123		120
124	dec [esi + ARP_entry.TTL]	121	dec [esi + ARP_entry.TTL]
125	jz .time_out	122	jz .time_out
126		123
127	.next:	124	.next:
128	add esi, sizeof.ARP_entry	125	add esi, sizeof.ARP_entry
129	dec ecx	126	dec ecx
130	jnz .loop	127	jnz .loop
131	jmp .exit	128	jmp .exit
132		129
133	.time_out:	130	.time_out:
134	cmp [esi + ARP_entry.Status], ARP_AWAITING_RESPONSE	131	cmp [esi + ARP_entry.Status], ARP_AWAITING_RESPONSE
135	je .response_timeout	132	je .response_timeout
136		133
137	push esi edi ecx	134	push esi edi ecx
138	call ARP_del_entry	135	call arp_del_entry
139	pop ecx edi esi	136	pop ecx edi esi
140		137
141	jmp .next	138	jmp .next
142		139
143	.response_timeout:	140	.response_timeout:
144	mov [esi + ARP_entry.Status], ARP_RESPONSE_TIMEOUT	141	mov [esi + ARP_entry.Status], ARP_RESPONSE_TIMEOUT
145	mov [esi + ARP_entry.TTL], 10	142	mov [esi + ARP_entry.TTL], 10
146		143
147	jmp .next	144	jmp .next
148		145
149	.exit:	146	.exit:
150	inc edi	147	inc edi
151	cmp edi, NET_DEVICES_MAX	148	cmp edi, NET_DEVICES_MAX
152	jb .loop_outer	149	jb .loop_outer
153		150
154	}	151	}
155		152
156		153
157	;-----------------------------------------------------------------	-
-		154	;-----------------------------------------------------------------;
158	;	155	; ;
159	; ARP_input	-
-		156	; arp_input ;
160	;	157	; ;
161	; IN: Pointer to buffer in [esp]	158	; IN: [esp] = Pointer to buffer ;
162	; size of buffer in [esp+4]	159	; [esp+4] = size of buffer ;
163	; packet size (without ethernet header) in ecx	160	; ecx = packet size (without ethernet header) ;
164	; packet ptr in edx	161	; edx = packet ptr ;
-		162	; ebx = device ptr ;
165	; device ptr in ebx	163	; ;
166	; OUT: /	-
-		164	; OUT: / ;
167	;	165	; ;
168	;-----------------------------------------------------------------	166	;-----------------------------------------------------------------;
169	align 4	167	align 4
170	ARP_input:	168	arp_input:
171		169
172	;-----------------------------------------	170	;-----------------------------------------
173	; Check validity and print some debug info	171	; Check validity and print some debug info
174		172
175	cmp ecx, sizeof.ARP_header	173	cmp ecx, sizeof.ARP_header
176	jb .exit	174	jb .exit
177		175
178	call NET_ptr_to_num4	176	call net_ptr_to_num4
179	cmp edi, -1	177	cmp edi, -1
180	jz .exit	178	jz .exit
181		179
182	inc [ARP_PACKETS_RX + edi] ; update stats	180	inc [ARP_PACKETS_RX + edi] ; update stats
183		181
184	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_input: got packet from %u.%u.%u.%u (device*4=%u)\n",\	182	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_input: got packet from %u.%u.%u.%u (device*4=%u)\n",\
185	[edx + ARP_header.SenderIP]:1, [edx + ARP_header.SenderIP + 1]:1,\	183	[edx + ARP_header.SenderIP]:1, [edx + ARP_header.SenderIP + 1]:1,\
186	[edx + ARP_header.SenderIP + 2]:1, [edx + ARP_header.SenderIP + 3]:1, edi	184	[edx + ARP_header.SenderIP + 2]:1, [edx + ARP_header.SenderIP + 3]:1, edi
187		185
188	;------------------------------	186	;------------------------------
189	; First, check for IP collision	187	; First, check for IP collision
190		188
191	mov eax, [edx + ARP_header.SenderIP]	189	mov eax, [edx + ARP_header.SenderIP]
192	cmp eax, [IP_LIST + edi]	190	cmp eax, [IP_LIST + edi]
193	je .collision	191	je .collision
194		192
195	;---------------------	193	;---------------------
196	; Handle reply packets	194	; Handle reply packets
197		195
198	cmp [edx + ARP_header.Opcode], ARP_REP_OPCODE	196	cmp [edx + ARP_header.Opcode], ARP_REP_OPCODE
199	jne .maybe_request	197	jne .maybe_request
200		198
201	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_input: It's a reply\n"	199	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_input: It's a reply\n"
202		200
203	mov ecx, [ARP_entries_num + edi]	201	mov ecx, [ARP_entries_num + edi]
204	test ecx, ecx	202	test ecx, ecx
205	jz .exit	203	jz .exit
206		204
207	mov esi, edi	205	mov esi, edi
208	imul esi, (ARP_TABLE_SIZE * sizeof.ARP_entry)/4	206	imul esi, (ARP_TABLE_SIZE * sizeof.ARP_entry)/4
209	add esi, ARP_table	207	add esi, ARP_table
210	.loop:	208	.loop:
211	cmp [esi + ARP_entry.IP], eax	209	cmp [esi + ARP_entry.IP], eax
212	je .gotit	210	je .gotit
213	add esi, sizeof.ARP_entry	211	add esi, sizeof.ARP_entry
214	dec ecx	212	dec ecx
215	jnz .loop	213	jnz .loop
216		214
217	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_input: no matching entry found\n"	215	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_input: no matching entry found\n"
218	jmp .exit	216	jmp .exit
219		217
220	.gotit:	218	.gotit:
221	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_input: found matching entry\n"	219	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_input: found matching entry\n"
222		220
223	cmp [esi + ARP_entry.TTL], ARP_STATIC_ENTRY ; if it is a static entry, dont touch it	221	cmp [esi + ARP_entry.TTL], ARP_STATIC_ENTRY ; if it is a static entry, dont touch it
224	je .exit	222	je .exit
225		223
226	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_input: updating entry\n"	224	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_input: updating entry\n"
227		225
228	mov [esi + ARP_entry.Status], ARP_VALID_MAPPING	226	mov [esi + ARP_entry.Status], ARP_VALID_MAPPING
229	mov [esi + ARP_entry.TTL], ARP_ENTRY_TTL	227	mov [esi + ARP_entry.TTL], ARP_ENTRY_TTL
230		228
231	mov eax, dword [edx + ARP_header.SenderMAC]	229	mov eax, dword [edx + ARP_header.SenderMAC]
232	mov dword [esi + ARP_entry.MAC], eax	230	mov dword [esi + ARP_entry.MAC], eax
233	mov cx, word [edx + ARP_header.SenderMAC + 4]	231	mov cx, word [edx + ARP_header.SenderMAC + 4]
234	mov word [esi + ARP_entry.MAC + 4], cx	232	mov word [esi + ARP_entry.MAC + 4], cx
235		233
236	jmp .exit	234	jmp .exit
237		235
238	;-----------------------	236	;-----------------------
239	; Handle request packets	237	; Handle request packets
240		238
241	.maybe_request:	239	.maybe_request:
242	cmp [edx + ARP_header.Opcode], ARP_REQ_OPCODE	240	cmp [edx + ARP_header.Opcode], ARP_REQ_OPCODE
243	jne .exit	241	jne .exit
244		242
245	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_input: its a request\n"	243	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_input: its a request\n"
246		244
247	mov eax, [IP_LIST + edi]	245	mov eax, [IP_LIST + edi]
248	cmp eax, [edx + ARP_header.TargetIP] ; Is it looking for my IP address?	246	cmp eax, [edx + ARP_header.TargetIP] ; Is it looking for my IP address?
249	jne .exit	247	jne .exit
250		248
251	push eax	249	push eax
252	push edi	250	push edi
253		251
254	; OK, it is a request for one of our MAC addresses.	252	; OK, it is a request for one of our MAC addresses.
255	; Build the frame and send it. We can reuse the buffer. (faster then using ARP_create_packet)	253	; Build the frame and send it. We can reuse the buffer. (faster then using ARP_create_packet)
256		254
257	lea esi, [edx + ARP_header.SenderMAC]	255	lea esi, [edx + ARP_header.SenderMAC]
258	lea edi, [edx + ARP_header.TargetMAC]	256	lea edi, [edx + ARP_header.TargetMAC]
259	movsd ; Move Sender Mac to Dest MAC	257	movsd ; Move Sender Mac to Dest MAC
260	movsw ;	258	movsw ;
261	movsd ; Move sender IP to Dest IP	259	movsd ; Move sender IP to Dest IP
262		260
263	pop esi	261	pop esi
264	mov esi, [NET_DRV_LIST + esi]	262	mov esi, [NET_DRV_LIST + esi]
265	lea esi, [esi + ETH_DEVICE.mac]	263	lea esi, [esi + ETH_DEVICE.mac]
266	lea edi, [edx + ARP_header.SenderMAC]	264	lea edi, [edx + ARP_header.SenderMAC]
267	movsd ; Copy MAC address from in MAC_LIST	265	movsd ; Copy MAC address from in MAC_LIST
268	movsw ;	266	movsw ;
269	pop eax	267	pop eax
270	stosd ; Write our IP	268	stosd ; Write our IP
271		269
272	mov [edx + ARP_header.Opcode], ARP_REP_OPCODE	270	mov [edx + ARP_header.Opcode], ARP_REP_OPCODE
273		271
274	; Now, Fill in ETHERNET header	272	; Now, Fill in ETHERNET header
275		273
276	mov edi, [esp]	274	mov edi, [esp]
277	lea esi, [edx + ARP_header.TargetMAC]	275	lea esi, [edx + ARP_header.TargetMAC]
278	movsd	276	movsd
279	movsw	277	movsw
280	lea esi, [edx + ARP_header.SenderMAC]	278	lea esi, [edx + ARP_header.SenderMAC]
281	movsd	279	movsd
282	movsw	280	movsw
283	; mov ax , ETHER_ARP ; It's already there, I'm sure of it!	281	; mov ax , ETHER_ARP ; It's already there, I'm sure of it!
284	; stosw	282	; stosw
285		283
286	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_input: Sending reply\n"	284	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_input: Sending reply\n"
287		285
288	call [ebx + NET_DEVICE.transmit]	286	call [ebx + NET_DEVICE.transmit]
289	ret	287	ret
290		288
291	.collision:	289	.collision:
292	inc [ARP_CONFLICTS + edi]	290	inc [ARP_CONFLICTS + edi]
293	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_input: IP address conflict detected!\n"	291	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_input: IP address conflict detected!\n"
294		292
295	.exit:	293	.exit:
296	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_input: exiting\n"	294	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_input: exiting\n"
297	call NET_BUFF_free	295	call net_buff_free
298	ret	296	ret
299		297
300	;---------------------------------------------------------------------------	-
-		298	;-----------------------------------------------------------------;
301	;	299	; ;
302	; ARP_output_request	-
-		300	; arp_output_request ;
303	;	301	; ;
304	; IN: ebx = device ptr	302	; IN: ebx = device ptr ;
305	; eax = IP	-
-		303	; eax = IP ;
306	; OUT: /	304	; ;
307	; scratched: probably everything	-
-		305	; OUT: scratched: probably everything ;
308	;	306	; ;
309	;---------------------------------------------------------------------------	307	;-----------------------------------------------------------------;
310	align 4	308	align 4
311	ARP_output_request:	309	arp_output_request:
312		310
313	push eax	311	push eax
314		312
315	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_output_request: ip=%u.%u.%u.%u device=0x%x\n",\	313	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_output_request: ip=%u.%u.%u.%u device=0x%x\n",\
316	[esp]:1, [esp + 1]:1, [esp + 2]:1, [esp + 3]:1, ebx	314	[esp]:1, [esp + 1]:1, [esp + 2]:1, [esp + 3]:1, ebx
317		315
318	mov ax, ETHER_PROTO_ARP	316	mov ax, ETHER_PROTO_ARP
319	mov ecx, sizeof.ARP_header	317	mov ecx, sizeof.ARP_header
320	mov edx, ETH_BROADCAST ; broadcast mac	318	mov edx, ETH_BROADCAST ; broadcast mac
321	call ETH_output	319	call eth_output
322	jz .exit	320	jz .exit
323		321
324	mov [edi + ARP_header.HardwareType], 0x0100 ; Ethernet	322	mov [edi + ARP_header.HardwareType], 0x0100 ; Ethernet
325	mov [edi + ARP_header.ProtocolType], 0x0008 ; IP	323	mov [edi + ARP_header.ProtocolType], 0x0008 ; IP
326	mov [edi + ARP_header.HardwareSize], 6 ; MAC-addr length	324	mov [edi + ARP_header.HardwareSize], 6 ; MAC-addr length
327	mov [edi + ARP_header.ProtocolSize], 4 ; IP-addr length	325	mov [edi + ARP_header.ProtocolSize], 4 ; IP-addr length
328	mov [edi + ARP_header.Opcode], ARP_REQ_OPCODE ; Request	326	mov [edi + ARP_header.Opcode], ARP_REQ_OPCODE ; Request
329		327
330	add edi, ARP_header.SenderMAC	328	add edi, ARP_header.SenderMAC
331	lea esi, [ebx + ETH_DEVICE.mac] ; SenderMac	329	lea esi, [ebx + ETH_DEVICE.mac] ; SenderMac
332	movsw ;	330	movsw ;
333	movsd ;	331	movsd ;
334		332
335	push edi	333	push edi
336	call NET_ptr_to_num4	334	call net_ptr_to_num4
337	inc [ARP_PACKETS_TX + edi] ; assume we will succeed	335	inc [ARP_PACKETS_TX + edi] ; assume we will succeed
338	lea esi, [IP_LIST + edi] ; SenderIP	336	lea esi, [IP_LIST + edi] ; SenderIP
339	pop edi	337	pop edi
340	movsd	338	movsd
341		339
342	mov esi, ETH_BROADCAST ; DestMac	340	mov esi, ETH_BROADCAST ; DestMac
343	movsw ;	341	movsw ;
344	movsd ;	342	movsd ;
345	popd [edi] ; DestIP	343	popd [edi] ; DestIP
346		344
347	push eax	345	push eax
348	call [ebx + NET_DEVICE.transmit]	346	call [ebx + NET_DEVICE.transmit]
349	ret	347	ret
350		348
351	.exit:	349	.exit:
352	add esp, 4	350	add esp, 4
353	DEBUGF DEBUG_NETWORK_ERROR, "ARP_output_request: send failed\n"	351	DEBUGF DEBUG_NETWORK_ERROR, "ARP_output_request: send failed\n"
354	ret	352	ret
355		353
356		354
357	;-----------------------------------------------------------------	-
-		355	;-----------------------------------------------------------------;
358	;	356	; ;
359	; ARP_add_entry (or update)	-
-		357	; arp_add_entry: Add or update an entry in the ARP table. ;
360	;	358	; ;
361	; IN: esi = ptr to entry (can easily be made on the stack)	359	; IN: esi = ptr to entry (can easily be made on the stack) ;
-		360	; edi = device num*4 ;
362	; edi = device num*4	361	; ;
-		362	; OUT: eax = entry number on success ;
363	; OUT: eax = entry #, -1 on error	363	; eax = -1 on error ;
364	; esi = ptr to newly created entry	-
-		364	; esi = ptr to newly created entry ;
365	;	365	; ;
366	;----------------------------------------------------------------- ; TODO: use a mutex	366	;-----------------------------------------------------------------;
367	align 4	367	align 4
-		368	arp_add_entry:
-		369
368	ARP_add_entry:	370	; TODO: use a mutex to lock ARP table
369		371
370	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_add_entry: device=%u\n", edi	372	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_add_entry: device=%u\n", edi
371		373
372	mov ecx, [ARP_entries_num + edi]	374	mov ecx, [ARP_entries_num + edi]
373	cmp ecx, ARP_TABLE_SIZE ; list full ?	375	cmp ecx, ARP_TABLE_SIZE ; list full ?
374	jae .full	376	jae .full
375		377
376	; From this point on, we can only fail if IP has a static entry, or if table is corrupt.	378	; From this point on, we can only fail if IP has a static entry, or if table is corrupt.
377		379
378	inc [ARP_entries_num + edi] ; assume we will succeed	380	inc [ARP_entries_num + edi] ; assume we will succeed
379		381
380	push edi	382	push edi
381	xor ecx, ecx	383	xor ecx, ecx
382	imul edi, ARP_TABLE_SIZE*sizeof.ARP_entry/4	384	imul edi, ARP_TABLE_SIZE*sizeof.ARP_entry/4
383	add edi, ARP_table	385	add edi, ARP_table
384	mov eax, [esi + ARP_entry.IP]	386	mov eax, [esi + ARP_entry.IP]
385	.loop:	387	.loop:
386	cmp [edi + ARP_entry.Status], ARP_NO_ENTRY ; is this slot empty?	388	cmp [edi + ARP_entry.Status], ARP_NO_ENTRY ; is this slot empty?
387	je .add	389	je .add
388		390
389	cmp [edi + ARP_entry.IP], eax ; if not, check if it doesnt collide	391	cmp [edi + ARP_entry.IP], eax ; if not, check if it doesnt collide
390	jne .maybe_next	392	jne .maybe_next
391		393
392	cmp [edi + ARP_entry.TTL], ARP_STATIC_ENTRY ; ok, its the same IP, update it if not static	394	cmp [edi + ARP_entry.TTL], ARP_STATIC_ENTRY ; ok, its the same IP, update it if not static
393	jne .add	395	jne .add
394		396
395	DEBUGF DEBUG_NETWORK_ERROR, "ARP_add_entry: failed, IP already has a static entry\n"	397	DEBUGF DEBUG_NETWORK_ERROR, "ARP_add_entry: failed, IP already has a static entry\n"
396	jmp .error	398	jmp .error
397		399
398	.maybe_next: ; try the next slot	400	.maybe_next: ; try the next slot
399	add edi, sizeof.ARP_entry	401	add edi, sizeof.ARP_entry
400	inc ecx	402	inc ecx
401	cmp ecx, ARP_TABLE_SIZE	403	cmp ecx, ARP_TABLE_SIZE
402	jb .loop	404	jb .loop
403		405
404	.add:	406	.add:
405	push ecx	407	push ecx
406	mov ecx, sizeof.ARP_entry/2	408	mov ecx, sizeof.ARP_entry/2
407	rep movsw	409	rep movsw
408	pop ecx	410	pop ecx
409	lea esi, [edi - sizeof.ARP_entry]	411	lea esi, [edi - sizeof.ARP_entry]
410	pop edi	412	pop edi
411	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_add_entry: entry=%u\n", ecx	413	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_add_entry: entry=%u\n", ecx
412		414
413	ret	415	ret
414		416
415	.error:	417	.error:
416	pop edi	418	pop edi
417	dec [ARP_entries_num + edi]	419	dec [ARP_entries_num + edi]
418	DEBUGF DEBUG_NETWORK_ERROR, "ARP_add_entry_failed\n"	420	DEBUGF DEBUG_NETWORK_ERROR, "ARP_add_entry_failed\n"
419	.full:	421	.full:
420	mov eax, -1	422	mov eax, -1
421	ret	423	ret
422		424
423		425
424	;-----------------------------------------------------------------	-
-		426	;-----------------------------------------------------------------;
425	;	427	; ;
426	; ARP_del_entry	-
-		428	; arp_del_entry: Remove an entry from the ARP table. ;
427	;	429	; ;
428	; IN: esi = ptr to arp entry	430	; IN: esi = ptr to arp entry ;
-		431	; edi = device number ;
429	; edi = device number	432	; ;
430	; OUT: /	-
-		433	; OUT: / ;
431	;	434	; ;
432	;-----------------------------------------------------------------	435	;-----------------------------------------------------------------;
433	align 4	436	align 4
-		437	arp_del_entry:
-		438
434	ARP_del_entry:	439	; TODO: use a mutex to lock ARP table
435		440
436	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_del_entry: entry=%x entrys=%u\n", esi, [ARP_entries_num + 4*edi]	441	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_del_entry: entry=0x%x entrys=%u\n", esi, [ARP_entries_num + 4*edi]
437	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_del_entry: IP=%u.%u.%u.%u\n", \	442	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_del_entry: IP=%u.%u.%u.%u\n", \
438	[esi + ARP_entry.IP]:1, [esi + ARP_entry.IP + 1]:1, [esi + ARP_entry.IP + 2]:1, [esi + ARP_entry.IP + 3]:1	443	[esi + ARP_entry.IP]:1, [esi + ARP_entry.IP + 1]:1, [esi + ARP_entry.IP + 2]:1, [esi + ARP_entry.IP + 3]:1
439		444
440	push edi	445	push edi
441	imul edi, (ARP_TABLE_SIZE) * sizeof.ARP_entry	446	imul edi, (ARP_TABLE_SIZE) * sizeof.ARP_entry
442	lea ecx, [ARP_table + (ARP_TABLE_SIZE - 1) * sizeof.ARP_entry + edi]	447	lea ecx, [ARP_table + (ARP_TABLE_SIZE - 1) * sizeof.ARP_entry + edi]
443	sub ecx, esi	448	sub ecx, esi
444	shr ecx, 1	449	shr ecx, 1
445		450
446	; move all trailing entries, sizeof.ARP_entry bytes to left.	451	; move all trailing entries, sizeof.ARP_entry bytes to left.
447	mov edi, esi	452	mov edi, esi
448	add esi, sizeof.ARP_entry	453	add esi, sizeof.ARP_entry
449	rep movsw	454	rep movsw
450		455
451	; now add an empty entry to the end (erasing previous one)	456	; now add an empty entry to the end (erasing previous one)
452	xor eax, eax	457	xor eax, eax
453	mov ecx, sizeof.ARP_entry/2	458	mov ecx, sizeof.ARP_entry/2
454	rep stosw	459	rep stosw
455		460
456	pop edi	461	pop edi
457	dec [ARP_entries_num + 4*edi]	462	dec [ARP_entries_num + 4*edi]
458	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_del_entry: success\n"	463	DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_del_entry: success\n"
459		464
460	ret	465	ret
461		466
462		467
463		468
464		469
465		470
466	;-----------------------------------------------------------------	-
467	;	471	;-----------------------------------------------------------------;
468	; ARP_IP_to_MAC	-
469	;	472	; ;
470	; This function translates an IP address to a MAC address	-
-		473	; arp_ip_to_mac: Translate an IP address to a MAC address. ;
471	;	474	; ;
472	; IN: eax = IPv4 address	475	; IN: eax = IPv4 address ;
-		476	; edi = device number * 4 ;
473	; edi = device number * 4	477	; ;

Subversion Repositories Kolibri OS

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