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

 ;;   22.09.2003 - [Mike Hibbett] : mikeh@oceanfree.net          ;;
 ;;   11.11.2006 - [Johnny_B] and [smb]                          ;;
 ;;                                                              ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 983 $
+$Revision: 2434 $
 ;example, static entry ->  db  11,22,33,44, 0x11,0x22,0x33,0x44,0x55,0x66, 0x01,0x00, 0xFF,0xFF
   times ( ARP_TABLE_SIZE - ARP_TABLE_ENTRIES ) * ARP_ENTRY_SIZE  db 0
 endg
+iglobal
-iglobal
+  NumARP:
-  NumARP:        dd    ARP_TABLE_ENTRIES
+                 dd    ARP_TABLE_ENTRIES
   ARPTable_ptr   dd    ARPTable   ;pointer to ARPTable
 endg
 align 4
 proc arp_table_manager stdcall uses ebx esi edi ecx edx,\
     Opcode:DWORD,Index:DWORD,Extra:DWORD
-    mov     ebx, dword[ARPTable_ptr]   ;ARPTable base
+        mov     ebx, dword[ARPTable_ptr];ARPTable base
-    mov     ecx, dword[NumARP]         ;ARP-entries counter
+        mov     ecx, dword[NumARP]     ;ARP-entries counter
-    mov     eax, dword[Opcode]
+        mov     eax, dword[Opcode]
-    cmp     eax, ARP_TABLE_TIMER
+        cmp     eax, ARP_TABLE_TIMER
-    je      .timer
+        je      .timer
-    cmp     eax, ARP_TABLE_ADD
+        cmp     eax, ARP_TABLE_ADD
-    je      .add
+        je      .add
-    cmp     eax, ARP_TABLE_DEL
+        cmp     eax, ARP_TABLE_DEL
-    je      .del
+        je      .del
-    cmp     eax, ARP_TABLE_GET
+        cmp     eax, ARP_TABLE_GET
-    je      .get
+        je      .get
-    cmp     eax, ARP_TABLE_IP_TO_MAC
+        cmp     eax, ARP_TABLE_IP_TO_MAC
-    je      .ip_to_mac
+        je      .ip_to_mac
-    cmp     eax, ARP_TABLE_GET_ENTRIES_NUMBER
+        cmp     eax, ARP_TABLE_GET_ENTRIES_NUMBER
-    je      .get_entries_number
+        je      .get_entries_number
-    jmp     .exit     ;if unknown opcode
+        jmp     .exit ;if unknown opcode
 ;;      Extra: must be zero
 ;;OUT:
 ;;  EAX=not defined
 ;;
 .timer:
-    test    ecx, ecx
+        test    ecx, ecx
-    jz      .exit    ;if NumARP=0 nothing to do
+        jz      .exit;if NumARP=0 nothing to do
-    sub     ecx, ARP_TABLE_ENTRIES  ;ecx=dynamic entries number
+        sub     ecx, ARP_TABLE_ENTRIES;ecx=dynamic entries number
-    jz      .exit    ;if NumARP=number of static entries then exit
+        jz      .exit;if NumARP=number of static entries then exit
-    add     ebx, ARP_TABLE_ENTRIES*ARP_ENTRY_SIZE  ;ebx=dynamic entries base
+        add     ebx, ARP_TABLE_ENTRIES*ARP_ENTRY_SIZE;ebx=dynamic entries base
   .timer_loop:
-    movsx   esi, word [ebx + ARP_ENTRY.TTL]
+        movsx   esi, word [ebx + ARP_ENTRY.TTL]
-    cmp     esi, 0xFFFFFFFF
+        cmp     esi, 0xFFFFFFFF
-    je      .timer_loop_end  ;if TTL==0xFFFF then it's static entry
+        je      .timer_loop_end;if TTL==0xFFFF then it's static entry
-    test    esi, esi
+        test    esi, esi
-    jnz     .timer_loop_end_with_dec  ;if TTL!=0
+        jnz     .timer_loop_end_with_dec;if TTL!=0
     ; Ok, TTL is 0
     ;if Status==AWAITING_RESPONSE and TTL==0
     ;then we have to change it to ARP_RESPONSE_TIMEOUT
-    cmp     word [ebx + ARP_ENTRY.Status], ARP_AWAITING_RESPONSE
+        cmp     word [ebx + ARP_ENTRY.Status], ARP_AWAITING_RESPONSE
-    jne     @f
+        jne     @f
-    mov     word [ebx + ARP_ENTRY.Status], ARP_RESPONSE_TIMEOUT
+        mov     word [ebx + ARP_ENTRY.Status], ARP_RESPONSE_TIMEOUT
-    mov     word [ebx + ARP_ENTRY.TTL], word 0x000A   ;10 sec
+        mov     word [ebx + ARP_ENTRY.TTL], word 0x000A;10 sec
-    jmp     .timer_loop_end
+        jmp     .timer_loop_end
   @@:
     ;if TTL==0 and Status==VALID_MAPPING, we have to delete it
     ;if TTL==0 and Status==RESPONSE_TIMEOUT, delete too
-    mov     esi, dword[NumARP]
+        mov     esi, dword[NumARP]
-    sub     esi, ecx          ;esi=index of entry, will be deleted
+        sub     esi, ecx      ;esi=index of entry, will be deleted
-    stdcall arp_table_manager,ARP_TABLE_DEL,esi,0 ;opcode,index,extra
+        stdcall arp_table_manager, ARP_TABLE_DEL, esi, 0;opcode,index,extra
-    jmp     .timer_loop_end
+        jmp     .timer_loop_end
   .timer_loop_end_with_dec:
-    dec     word [ebx + ARP_ENTRY.TTL]  ;decrease TTL
+        dec     word [ebx + ARP_ENTRY.TTL];decrease TTL
 ;;OUT:
 ;;  EAX=index of entry, that has been added
 ;;
 .add:
-    sub     esp, ARP_ENTRY_SIZE   ;Allocate ARP_ENTRY_SIZE byte in stack
+        sub     esp, ARP_ENTRY_SIZE;Allocate ARP_ENTRY_SIZE byte in stack
-    mov     esi, [Extra]   ;pointer
+        mov     esi, [Extra];pointer
-    mov     edi, [Index]   ;opcode
+        mov     edi, [Index];opcode
-    cmp     edi, EXTRA_IS_ARP_PACKET_PTR
+        cmp     edi, EXTRA_IS_ARP_PACKET_PTR
-    je      .arp_packet_to_entry ;if Extra contain ptr to ARP_PACKET and we have to form arp-entry
+        je      .arp_packet_to_entry;if Extra contain ptr to ARP_PACKET and we have to form arp-entry
                                  ;else it contain ptr to arp-entry
-    cld
+        cld
           ; esi already has been loaded
-    mov     edi, esp      ;ebx + eax=ARPTable_base + ARP-entry_base(where we will add)
+        mov     edi, esp  ;ebx + eax=ARPTable_base + ARP-entry_base(where we will add)
-    mov     ecx,ARP_ENTRY_SIZE/2  ;ARP_ENTRY_SIZE must be even number!!!
+        mov     ecx, ARP_ENTRY_SIZE/2;ARP_ENTRY_SIZE must be even number!!!
-    rep     movsw    ;copy
+        rep movsw    ;copy
-    jmp     .search
+        jmp     .search
   .arp_packet_to_entry:
-    mov     edx, dword[esi + ARP_PACKET.SenderIP] ;esi=base of ARP_PACKET
+        mov     edx, dword[esi + ARP_PACKET.SenderIP];esi=base of ARP_PACKET
-    mov     [esp + ARP_ENTRY.IP], edx
+        mov     [esp + ARP_ENTRY.IP], edx
-    cld
+        cld
-    lea     esi, [esi + ARP_PACKET.SenderMAC]
+        lea     esi, [esi + ARP_PACKET.SenderMAC]
-    lea     edi, [esp + ARP_ENTRY.MAC]
+        lea     edi, [esp + ARP_ENTRY.MAC]
-    movsd
+        movsd
-    movsw
+        movsw
-    mov     word[esp + ARP_ENTRY.Status], ARP_VALID_MAPPING  ; specify the type - a valid entry
+        mov     word[esp + ARP_ENTRY.Status], ARP_VALID_MAPPING; specify the type - a valid entry
-    mov     word[esp + ARP_ENTRY.TTL], 0x0E10    ; = 1 hour
+        mov     word[esp + ARP_ENTRY.TTL], 0x0E10; = 1 hour
   .search:
-    mov     edx, dword[esp + ARP_ENTRY.IP]  ;edx=IP-address, which we'll search
+        mov     edx, dword[esp + ARP_ENTRY.IP];edx=IP-address, which we'll search
-    mov     ecx, dword[NumARP]              ;ecx=ARP-entries counter
+        mov     ecx, dword[NumARP]          ;ecx=ARP-entries counter
-    jecxz   .add_to_end                     ;if ARP-entries number == 0
+        jecxz   .add_to_end                 ;if ARP-entries number == 0
-    imul    eax, ecx, ARP_ENTRY_SIZE        ;eax=current table size(in bytes)
+        imul    eax, ecx, ARP_ENTRY_SIZE    ;eax=current table size(in bytes)
   @@:
-    sub     eax, ARP_ENTRY_SIZE
+        sub     eax, ARP_ENTRY_SIZE
-    cmp     dword[ebx + eax + ARP_ENTRY.IP], edx
+        cmp     dword[ebx + eax + ARP_ENTRY.IP], edx
-    loopnz  @b
+        loopnz  @b
-    jz      .replace       ; found, replace existing entry, ptr to it is in eax
+        jz      .replace   ; found, replace existing entry, ptr to it is in eax
   .add_to_end:
     ;else add to end
-    or      eax,-1    ;set eax=0xFFFFFFFF if adding is impossible
+        or      eax, -1;set eax=0xFFFFFFFF if adding is impossible
-    mov     ecx, dword[NumARP]
+        mov     ecx, dword[NumARP]
-    cmp     ecx, ARP_TABLE_SIZE
+        cmp     ecx, ARP_TABLE_SIZE
-    je      .add_exit   ;if arp-entries number is equal to arp-table maxsize
+        je      .add_exit;if arp-entries number is equal to arp-table maxsize
-    imul    eax, dword[NumARP], ARP_ENTRY_SIZE ;eax=ptr to end of ARPTable
+        imul    eax, dword[NumARP], ARP_ENTRY_SIZE;eax=ptr to end of ARPTable
-    inc     dword [NumARP]    ;increase ARP-entries counter
+        inc     dword [NumARP];increase ARP-entries counter
   .replace:
-    cld
+        cld
-    mov     esi, esp              ;esp=base of ARP-entry, that will be added
+        mov     esi, esp          ;esp=base of ARP-entry, that will be added
-    lea     edi, [ebx + eax]      ;ebx + eax=ARPTable_base + ARP-entry_base(where we will add)
+        lea     edi, [ebx + eax]  ;ebx + eax=ARPTable_base + ARP-entry_base(where we will add)
-    mov     ecx,ARP_ENTRY_SIZE/2  ;ARP_ENTRY_SIZE must be even number!!!
+        mov     ecx, ARP_ENTRY_SIZE/2;ARP_ENTRY_SIZE must be even number!!!
-    rep     movsw
+        rep movsw
 ;;      Extra: must be zero
 ;;OUT:
 ;;  EAX=not defined
 ;;
 .del:
-    mov     esi, [Index]
+        mov     esi, [Index]
-    imul    esi, ARP_ENTRY_SIZE
+        imul    esi, ARP_ENTRY_SIZE
-    mov     ecx, (ARP_TABLE_SIZE - 1) * ARP_ENTRY_SIZE
+        mov     ecx, (ARP_TABLE_SIZE - 1) * ARP_ENTRY_SIZE
-    sub     ecx, esi
+        sub     ecx, esi
-    lea     edi, [ebx + esi]            ;edi=ptr to entry that should be deleted
+        lea     edi, [ebx + esi]        ;edi=ptr to entry that should be deleted
-    lea     esi, [edi + ARP_ENTRY_SIZE] ;esi=ptr to next entry
+        lea     esi, [edi + ARP_ENTRY_SIZE];esi=ptr to next entry
-    shr     ecx,1      ;ecx/2 => ARP_ENTRY_SIZE MUST BE EVEN NUMBER!
+        shr     ecx, 1 ;ecx/2 => ARP_ENTRY_SIZE MUST BE EVEN NUMBER!
-    cld
+        cld
-    rep     movsw
+        rep movsw
-    dec     dword[NumARP] ;decrease arp-entries counter
+        dec     dword[NumARP];decrease arp-entries counter
-    jmp     .exit
+        jmp     .exit
 ;;      Extra: pointer to buffer for reading(size must be equal to ARP_ENTRY_SIZE)
 ;;OUT:
 ;;  EAX=not defined
 ;;
 .get:
-    mov     esi, [Index]
+        mov     esi, [Index]
-    imul    esi, ARP_ENTRY_SIZE   ;esi=ptr to required ARP_ENTRY
+        imul    esi, ARP_ENTRY_SIZE;esi=ptr to required ARP_ENTRY
-    mov     edi, [Extra]          ;edi=buffer for reading
+        mov     edi, [Extra]      ;edi=buffer for reading
-    mov     ecx, ARP_ENTRY_SIZE/2 ; must be even number!!!
+        mov     ecx, ARP_ENTRY_SIZE/2; must be even number!!!
-    cld
+        cld
-    rep     movsw
+        rep movsw
-    jmp     .exit
+        jmp     .exit
 ;;END GET
 ;;BEGIN IP_TO_MAC
 ;;Description: it gets an IP from Index, scans each entry in the table and writes
 ;;  resolved, or that doesn't exist. I recommend you, to do at most 3-5 calls of this
 ;;  function with 1sec delay. sure, only if it not return a valid MAC after a first call.
 ;;
 .ip_to_mac:
-    xor     eax, eax
+        xor     eax, eax
-    mov     edi, dword[Extra]
+        mov     edi, dword[Extra]
-    cld
+        cld
-    stosd
+        stosd
-    stosw
+        stosw
     ; first, check destination IP to see if it is on 'this' network.
     ; The test is:
     ; if ( destIP & subnet_mask == stack_ip & subnet_mask )
     ;   destination is local
     ; else
     ;  destination is remote, so pass to gateway
-    mov     eax, [Index]       ;eax=required IP
+        mov     eax, [Index]   ;eax=required IP
-    mov     esi, eax
+        mov     esi, eax
-    and     esi, [subnet_mask]
+        and     esi, [subnet_mask]
-    mov     ecx, [stack_ip]
+        mov     ecx, [stack_ip]
-    and     ecx, [subnet_mask]
+        and     ecx, [subnet_mask]
-    cmp     esi, ecx
+        cmp     esi, ecx
-    je      @f        ;if we and target IP are located in the same network
+        je      @f    ;if we and target IP are located in the same network
-    mov     eax, [gateway_ip]
+        mov     eax, [gateway_ip]
-    mov     [Index], eax
+        mov     [Index], eax
   @@:
-    cmp     dword[NumARP], 0
+        cmp     dword[NumARP], 0
-    je      .ip_to_mac_send_request ;if ARP-table not contain an entries, we have to request IP.
+        je      .ip_to_mac_send_request;if ARP-table not contain an entries, we have to request IP.
                                     ;EAX will be containing a zero, it's equal to ARP_NO_ENTRY
-    mov     ecx, dword[NumARP]
+        mov     ecx, dword[NumARP]
-    imul    esi, ecx, ARP_ENTRY_SIZE  ;esi=current ARP-table size
+        imul    esi, ecx, ARP_ENTRY_SIZE;esi=current ARP-table size
   @@:
-    sub     esi, ARP_ENTRY_SIZE
+        sub     esi, ARP_ENTRY_SIZE
-    cmp     [ebx + esi], eax         ; ebx=ARPTable base
+        cmp     [ebx + esi], eax     ; ebx=ARPTable base
-    loopnz  @b                       ; Return back if non match
+        loopnz  @b                   ; Return back if non match
-    jnz     .ip_to_mac_send_request  ; and request IP->MAC if none found in the table
+        jnz     .ip_to_mac_send_request; and request IP->MAC if none found in the table
     ; Return the entry status in eax
-    movzx   eax, word[ebx + esi + ARP_ENTRY.Status]
+        movzx   eax, word[ebx + esi + ARP_ENTRY.Status]
     ; esi holds index
-    cld
+        cld
-    lea     esi, [ebx + esi + ARP_ENTRY.MAC]
+        lea     esi, [ebx + esi + ARP_ENTRY.MAC]
-    mov     edi, [Extra]   ;edi=ptr to buffer for write MAC
+        mov     edi, [Extra];edi=ptr to buffer for write MAC
-    movsd
+        movsd
 ;;      Index: must be zero
 ;;      Extra: must be zero
 ;;OUT:
 ;;  EAX=ARP-entries number in the ARPTable
   .get_entries_number:
-    mov     eax, dword[NumARP]
+        mov     eax, dword[NumARP]
-    jmp     .exit
+        jmp     .exit
 ;;END GET_ENTRIES_NUMBER
 .exit:
-    ret
+        ret
 endp
     ; Is this a REQUEST?
     ; Is this a request for My Host IP
     ; Yes - So construct a response message.
     ; Send this message to the ethernet card for transmission
-    stdcall arp_table_manager,ARP_TABLE_ADD,EXTRA_IS_ARP_PACKET_PTR,ETH_FRAME.Data + ARP_PACKET
+        stdcall arp_table_manager, ARP_TABLE_ADD, EXTRA_IS_ARP_PACKET_PTR, ETH_FRAME.Data + ARP_PACKET
-    inc     dword[arp_rx_count] ;increase ARP-packets counter
+        inc     dword[arp_rx_count];increase ARP-packets counter
-    cmp     word[ETH_FRAME.Data + ARP_PACKET.Opcode], ARP_REQ_OPCODE  ; Is this a request packet?
+        cmp     word[ETH_FRAME.Data + ARP_PACKET.Opcode], ARP_REQ_OPCODE; Is this a request packet?
-    jne     .exit            ; No - so exit
+        jne     .exit        ; No - so exit
-    mov     eax, [stack_ip]
+        mov     eax, [stack_ip]
-    cmp     eax, dword[ETH_FRAME.Data + ARP_PACKET.TargetIP]         ; Is it looking for my IP address?
+        cmp     eax, dword[ETH_FRAME.Data + ARP_PACKET.TargetIP]     ; Is it looking for my IP address?
-    jne     .exit            ; No - so quit now
+        jne     .exit        ; No - so quit now
     ; OK, it is a request for my MAC address. Build the frame and send it
     ; We can reuse the packet.
-    mov     word[ETH_FRAME.Data + ARP_PACKET.Opcode], ARP_REP_OPCODE
+        mov     word[ETH_FRAME.Data + ARP_PACKET.Opcode], ARP_REP_OPCODE
-    cld
+        cld
-    mov     esi, ETH_FRAME.Data + ARP_PACKET.SenderMAC
+        mov     esi, ETH_FRAME.Data + ARP_PACKET.SenderMAC
-    mov     edi, ETH_FRAME.Data + ARP_PACKET.TargetMAC
+        mov     edi, ETH_FRAME.Data + ARP_PACKET.TargetMAC
-    movsd
+        movsd
-    movsw
+        movsw
-    mov     esi, ETH_FRAME.Data + ARP_PACKET.SenderIP
+        mov     esi, ETH_FRAME.Data + ARP_PACKET.SenderIP
-    mov     edi, ETH_FRAME.Data + ARP_PACKET.TargetIP
+        mov     edi, ETH_FRAME.Data + ARP_PACKET.TargetIP
-    movsd
+        movsd
-    mov     esi, node_addr
+        mov     esi, node_addr
-    mov     edi, ETH_FRAME.Data + ARP_PACKET.SenderMAC
+        mov     edi, ETH_FRAME.Data + ARP_PACKET.SenderMAC
-    movsd
+        movsd
-    movsw
+        movsw
-    mov     esi, stack_ip
+        mov     esi, stack_ip
-    mov     edi, ETH_FRAME.Data + ARP_PACKET.SenderIP
+        mov     edi, ETH_FRAME.Data + ARP_PACKET.SenderIP
-    movsd
+        movsd
     ; Now, send it!
-    mov     edi, ETH_FRAME.Data + ARP_PACKET.TargetMAC   ;ptr to destination MAC address
+        mov     edi, ETH_FRAME.Data + ARP_PACKET.TargetMAC;ptr to destination MAC address
-    mov     bx, ETHER_ARP               ;type of protocol
+        mov     bx, ETHER_ARP           ;type of protocol
-    mov     ecx, 28                     ;data size
+        mov     ecx, 28                 ;data size
-    mov     esi, ETH_FRAME.Data + ARP_PACKET             ;ptr to data
+        mov     esi, ETH_FRAME.Data + ARP_PACKET         ;ptr to data
+;
 ;***************************************************************************
 proc arp_request stdcall uses ebx esi edi,\
     TargetIP:DWORD, SenderIP_ptr:DWORD, SenderMAC_ptr:DWORD
-    inc     dword[arp_tx_count]  ; increase counter
+        inc     dword[arp_tx_count]; increase counter
-    sub     esp, 28  ; allocate memory for ARP_PACKET
+        sub     esp, 28; allocate memory for ARP_PACKET
-    mov     word[esp + ARP_PACKET.HardwareType],0x0100 ;Ethernet
+        mov     word[esp + ARP_PACKET.HardwareType], 0x0100;Ethernet
-    mov     word[esp + ARP_PACKET.ProtocolType],0x0008 ;IP
+        mov     word[esp + ARP_PACKET.ProtocolType], 0x0008;IP
-    mov     byte[esp + ARP_PACKET.HardwareSize],0x06   ;MAC-addr length
+        mov     byte[esp + ARP_PACKET.HardwareSize], 0x06;MAC-addr length
-    mov     byte[esp + ARP_PACKET.ProtocolSize],0x04   ;IP-addr length
+        mov     byte[esp + ARP_PACKET.ProtocolSize], 0x04;IP-addr length
-    mov     word[esp + ARP_PACKET.Opcode],0x0100       ;Request
+        mov     word[esp + ARP_PACKET.Opcode], 0x0100  ;Request
-    cld
+        cld
-    mov     esi,[SenderMAC_ptr]
+        mov     esi, [SenderMAC_ptr]
-    lea     edi,[esp + ARP_PACKET.SenderMAC]       ;Our MAC-addr
+        lea     edi, [esp + ARP_PACKET.SenderMAC]  ;Our MAC-addr
-    movsd
+        movsd
-    movsw
+        movsw
-    mov     esi,[SenderIP_ptr]
+        mov     esi, [SenderIP_ptr]
-    lea     edi,[esp + ARP_PACKET.SenderIP]        ;Our IP-addr
+        lea     edi, [esp + ARP_PACKET.SenderIP]   ;Our IP-addr
-    movsd
+        movsd
-    xor     eax, eax
+        xor     eax, eax
-    lea     edi, [esp + ARP_PACKET.TargetMAC]      ;Required MAC-addr(zeroed)
+        lea     edi, [esp + ARP_PACKET.TargetMAC]  ;Required MAC-addr(zeroed)
-    stosd
+        stosd
-    stosw
+        stosw
-    mov     esi, dword[TargetIP]
+        mov     esi, dword[TargetIP]
-    mov     dword[esp + ARP_PACKET.TargetIP],esi   ;Required IP-addr(we get it as function parameter)
+        mov     dword[esp + ARP_PACKET.TargetIP], esi;Required IP-addr(we get it as function parameter)
     ; Now, send it!
-    mov     edi, broadcast_add     ; Pointer to 48 bit destination address
+        mov     edi, broadcast_add ; Pointer to 48 bit destination address
-    mov     bx, ETHER_ARP          ; Type of packet
+        mov     bx, ETHER_ARP      ; Type of packet
-    mov     ecx, 28                ; size of packet
+        mov     ecx, 28            ; size of packet
-    lea     esi, [esp + ARP_PACKET]; pointer to packet data
+        lea     esi, [esp + ARP_PACKET]; pointer to packet data
-    push    ebp
+        push    ebp
-    call    dword [drvr_transmit]  ; Call the drivers transmit function
+        call    dword [drvr_transmit]; Call the drivers transmit function
-    pop     ebp
+        pop     ebp
-    add     esp, 28  ; free memory, allocated before for ARP_PACKET
+        add     esp, 28; free memory, allocated before for ARP_PACKET
     ; Add an entry in the ARP table, awaiting response
-    sub     esp, ARP_ENTRY_SIZE    ;allocate memory for ARP-entry
+        sub     esp, ARP_ENTRY_SIZE;allocate memory for ARP-entry
-    mov     esi, dword[TargetIP]
+        mov     esi, dword[TargetIP]
-    mov     dword[esp + ARP_ENTRY.IP],esi
+        mov     dword[esp + ARP_ENTRY.IP], esi
-    lea     edi, [esp + ARP_ENTRY.MAC]
+        lea     edi, [esp + ARP_ENTRY.MAC]
-    xor     eax, eax
+        xor     eax, eax

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/network/eth_drv/arp.inc – Rev 1635 → 2434