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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;  ARP.INC                                                     ;;
;;                                                              ;;
;;  Address Resolution Protocol                                 ;;
;;                                                              ;;
;;  This file contains the following:                           ;;
;;   arp_table_manager - Manages an ARPTable                    ;;
;;   arp_request - Sends an ARP request on the ethernet         ;;
;;   arp_handler - Called when an ARP packet is received        ;;
;;                                                              ;;
;;  Changes history:                                            ;;
;;   22.09.2003 - [Mike Hibbett] : mikeh@oceanfree.net          ;;
;;   11.11.2006 - [Johnny_B] and [smb]                          ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 983 $
 
 
ARP_NO_ENTRY		equ  0
ARP_VALID_MAPPING	equ  1
ARP_AWAITING_RESPONSE	equ  2
ARP_RESPONSE_TIMEOUT	equ  3
 
ETHER_ARP		equ  0x0608
 
ARP_REQ_OPCODE		equ  0x0100  ; request
ARP_REP_OPCODE		equ  0x0200  ; reply
 
ARP_TABLE_SIZE		equ  20      ; Size of table
 
struct ARP_ENTRY
       .IP		dd  ?
       .MAC		dp  ?
       .Status		dw  ?
       .TTL		dw  ?  ; in seconds
       .size:
ends
 
struct ARP_Packet
       .HardwareType	dw  ?
       .ProtocolType	dw  ?
       .HardwareSize	db  ?
       .ProtocolSize	db  ?
       .Opcode		dw  ?
       .SenderMAC	dp  ?
       .SenderIP	dd  ?
       .TargetMAC	dp  ?
       .TargetIP	dd  ?
ends
 
 
; 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
 
align 4
uglobal
 
	NumARP		dd ?
	ARPTable	rb ARP_ENTRY.size * ARP_TABLE_SIZE
 
	ARP_PACKETS_TX	rd  MAX_NET_DEVICES
	ARP_PACKETS_RX	rd  MAX_NET_DEVICES
 
 
endg
 
 
 
 
ARP_init:
 
	xor	eax, eax
 
	mov	[NumARP], eax
 
	mov	edi, ARP_PACKETS_TX
	mov	ecx, 2*MAX_NET_DEVICES
	rep	stosd
 
	ret
 
 
 
 
;***************************************************************************
;   Function
;      arp_table_manager  [by Johnny_B]
;
;   Description
;     Does a most required operations with ARP-table
;  IN:
;   Operation: see Opcode's constants below
;       Index: Index of entry in the ARP-table
;       Extra: Extra parameter for some Opcodes
;  OUT:
;   EAX = Returned value depends on opcodes, more detailed see below
;
;***************************************************************************
;Opcode's constants
ARP_TABLE_ADD		      equ  1
ARP_TABLE_DEL		      equ  2
ARP_TABLE_GET		      equ  3
ARP_TABLE_GET_ENTRIES_NUMBER  equ  4
ARP_TABLE_IP_TO_MAC	      equ  5
ARP_TABLE_TIMER 	      equ  6
 
;Index's constants
EXTRA_IS_ARP_PACKET_PTR  equ  0   ;if Extra contain pointer to ARP_Packet
EXTRA_IS_ARP_ENTRY_PTR	 equ  -1  ;if Extra contain pointer to ARP_ENTRY
 
align 4
proc arp_table_manager stdcall uses ebx esi edi ecx edx, Opcode:DWORD,Index:DWORD,Extra:DWORD
 
    mov     ebx, ARPTable  ;ARPTable base
    mov     ecx, dword[NumARP]	       ;ARP-entries counter
 
    mov     eax, dword[Opcode]
 
    cmp     eax, ARP_TABLE_TIMER
    je	    .timer
 
    DEBUGF 1,"ARP table manager opcode:%u numARP:%u\n",eax,ecx
 
    cmp     eax, ARP_TABLE_ADD
    je	    .add
    cmp     eax, ARP_TABLE_DEL
    je	    .del
    cmp     eax, ARP_TABLE_GET
    je	    .get
    cmp     eax, ARP_TABLE_IP_TO_MAC
    je	    .ip_to_mac
    cmp     eax, ARP_TABLE_GET_ENTRIES_NUMBER
    je	    .get_entries_number
    jmp     .exit     ;if unknown opcode
 
 
;;BEGIN TIMER
;;Description: it must be callback every second. It is responsible for removing expired routes.
;;IN:   Operation: ARP_TABLE_TIMER
;;      Index: must be zero
;;      Extra: must be zero
;;OUT:
;;  EAX=not defined
;;
.timer:
    test    ecx, ecx
    jz	    .exit    ;if NumARP=0 nothing to do
;    sub     ecx, ARP_TABLE_ENTRIES  ;ecx=dynamic entries number
;    jz      .exit    ;if NumARP=number of static entries then exit
 
;    add     ebx, ARP_TABLE_ENTRIES*ARP_ENTRY_SIZE  ;ebx=dynamic entries base
 
  .timer_loop:
    movsx   esi, word [ebx + ARP_ENTRY.TTL]
    cmp     esi, 0xFFFFFFFF
    je	    .timer_loop_end  ;if TTL==0xFFFF then it's static entry
 
    test    esi, esi
    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
    jne     @f
 
    mov     word [ebx + ARP_ENTRY.Status], ARP_RESPONSE_TIMEOUT
    mov     word [ebx + ARP_ENTRY.TTL], word 0x000A   ;10 sec
    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]
    sub     esi, ecx	      ;esi=index of entry, will be deleted
    stdcall arp_table_manager,ARP_TABLE_DEL,esi,0 ;opcode,index,extra
    jmp     .timer_loop_end
 
 
  .timer_loop_end_with_dec:
    dec     word [ebx + ARP_ENTRY.TTL]	;decrease TTL
  .timer_loop_end:
    add     ebx, ARP_ENTRY.size
    loop    .timer_loop
 
    jmp     .exit
;;END TIMER
 
;;BEGIN ADD
;;Description: it adds an entry in the table. If ARP-table already
;;             contains same IP, it will be updated.
;;IN:   Operation: ARP_TABLE_ADD
;;      Index: specifies what contains Extra-parameter
;;      Extra: if Index==EXTRA_IS_ARP_Packet_PTR,
;;             then Extra contains pointer to ARP_Packet,
;;             otherwise Extra contains pointer to ARP_ENTRY
;;OUT:
;;  EAX=index of entry, that has been added
;;
.add:
 
    DEBUGF 1,"1"
 
    sub     esp, ARP_ENTRY.size   ;Allocate ARP_ENTRY_SIZE byte in stack
 
    mov     esi, [Extra]   ;pointer
    mov     edi, [Index]   ;opcode
 
    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
				 ;else it contain ptr to arp-entry
 
    DEBUGF 1,"2"
 
    cld
	  ; esi already has been loaded
    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!!!
    rep     movsw    ;copy
    jmp     .search
 
  .ARP_Packet_to_entry:
 
    DEBUGF 1,"3"
    mov     edx, dword[esi + ARP_Packet.SenderIP] ;esi=base of ARP_Packet
    mov     [esp + ARP_ENTRY.IP], edx
 
    cld
    lea     esi, [esi + ARP_Packet.SenderMAC]
    lea     edi, [esp + ARP_ENTRY.MAC]
    movsd
    movsw
    mov     word[esp + ARP_ENTRY.Status], ARP_VALID_MAPPING  ; specify the type - a valid entry
    mov     word[esp + ARP_ENTRY.TTL], 0x0E10	 ; = 1 hour
 
  .search:
 
    DEBUGF 1,"4"
    mov     edx, dword[esp + ARP_ENTRY.IP]  ;edx=IP-address, which we'll search
    mov     ecx, dword[NumARP]		    ;ecx=ARP-entries counter
    jecxz   .add_to_end 		    ;if ARP-entries number == 0
    imul    eax, ecx, ARP_ENTRY.size	    ;eax=current table size(in bytes)
  @@:
    sub     eax, ARP_ENTRY.size
    cmp     dword[ebx + eax + ARP_ENTRY.IP], edx
    loopnz  @b
;    jz      .replace       ; found, replace existing entry, ptr to it is in eax
 
  .add_to_end:
;
;    DEBUGF 1,"5\n"
;    ;else add to end
;    or      eax,-1    ;set eax=0xFFFFFFFF if adding is impossible
;    mov     ecx, dword[NumARP]
;    cmp     ecx, ARP_TABLE_SIZE
;    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
;    inc     dword [NumARP]    ;increase ARP-entries counter
 
;  .replace:
    DEBUGF 1,"Updating ARP entry: %x-%x-%x-%x-%x-%x = %u.%u.%u.%u to slot:%u\n",\
    [esp + ARP_ENTRY.MAC]:2,[esp + ARP_ENTRY.MAC+1]:2,[esp + ARP_ENTRY.MAC+2]:2,[esp + ARP_ENTRY.MAC+3]:2,[esp + ARP_ENTRY.MAC+4]:2,[esp + ARP_ENTRY.MAC+5]:2,\
    [esp + ARP_ENTRY.IP]:1,[esp + ARP_ENTRY.IP+1]:1,[esp + ARP_ENTRY.IP+2]:1,[esp + ARP_ENTRY.IP+3]:1,eax
 
    cld
    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)
    mov     ecx,ARP_ENTRY.size/2  ;ARP_ENTRY_SIZE must be even number!!!
    rep     movsw
 
    mov     ecx, ARP_ENTRY.size
    xor     edx, edx  ;"div" takes operand from EDX:EAX
    div     ecx       ;eax=index of entry, which has been added
 
 
 
.add_exit:
 
    add     esp, ARP_ENTRY.size   ;free stack
    jmp     .exit
;;END ADD
 
;;BEGIN DEL
;;Description: it deletes an entry in the table.
;;IN:   Operation: ARP_TABLE_DEL
;;      Index: index of entry, that should be deleted
;;      Extra: must be zero
;;OUT:
;;  EAX=not defined
;;
.del:
    mov     esi, [Index]
    imul    esi, ARP_ENTRY.size
 
    mov     ecx, (ARP_TABLE_SIZE - 1) * ARP_ENTRY.size
    sub     ecx, esi
 
    lea     edi, [ebx + esi]		;edi=ptr to entry that should be deleted
    lea     esi, [edi + ARP_ENTRY.size] ;esi=ptr to next entry
 
    shr     ecx,1      ;ecx/2 => ARP_ENTRY_SIZE MUST BE EVEN NUMBER!
    cld
    rep     movsw
 
    dec     dword[NumARP] ;decrease arp-entries counter
    jmp     .exit
;;END DEL
 
;;BEGIN GET
;;Description: it reads an entry of table into buffer.
;;IN:   Operation: ARP_TABLE_GET
;;      Index: index of entry, that should be read
;;      Extra: pointer to buffer for reading(size must be equal to ARP_ENTRY_SIZE)
;;OUT:
;;  EAX=not defined
;;
.get:
    mov     esi, [Index]
    imul    esi, ARP_ENTRY.size  ;esi=ptr to required ARP_ENTRY
    mov     edi, [Extra]	  ;edi=buffer for reading
    mov     ecx, ARP_ENTRY.size/2 ; must be even number!!!
    cld
    rep     movsw
    jmp     .exit
;;END GET
 
;;BEGIN IP_TO_MAC
;;Description: it gets an IP from Index, scans each entry in the table and writes
;;             MAC, that relates to specified IP, into buffer specified in Extra.
;;             And if it cannot find an IP-address in the table, it does an ARP-request of that.
;;IN:   Operation: ARP_TABLE_IP_TO_MAC
;;      Index: IP that should be transformed into MAC
;;      Extra: pointer to buffer where will be written the MAC-address.
;;OUT:
;;  EAX=ARP table entry status code.
;;      If EAX==ARP_NO_ENTRY, IP isn't found in the table and we have sent the request.
;;      If EAX==ARP_AWAITING_RESPONSE, we wait the response from remote system.
;;      If EAX==ARP_RESPONSE_TIMEOUT, remote system not responds too long.
;;      If EAX==ARP_VALID_MAPPING, all is ok, we've got a true MAC.
;;
;;  If MAC will equal to a zero, in the buffer. It means, that IP-address was not yet
;;  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:
 
    DEBUGF 1,"Trying to find MAC for %u.%u.%u.%u\n",[Index]:1,[Index+1]:1,[Index+2]:1,[Index+3]:1
 
    xor     eax, eax
    mov     edi, dword[Extra]
    cld
    stosd
    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
 
 
;;; TODO: get device number ! (in edx)
    xor     edx, edx
 
    mov     eax, [Index]       ;eax=required IP
    mov     esi, eax
    and     esi, [SUBNET_LIST+edx]
    mov     ecx, [IP_LIST+edx]
    and     ecx, [SUBNET_LIST+edx]
    cmp     esi, ecx
    je	    @f	      ;if we and target IP are located in the same network
    mov     eax, [GATEWAY_LIST+edx]
    mov     [Index], eax
    DEBUGF 1,"IP is not on subnet, using %u.%u.%u.%u instead\n",[Index]:1,[Index+1]:1,[Index+2]:1,[Index+3]:1
  @@:
 
    cmp     dword[NumARP], 0
    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]
    imul    esi, ecx, ARP_ENTRY.size  ;esi=current ARP-table size
 
  @@:
    sub     esi, ARP_ENTRY.size
    cmp     [ebx + esi + ARP_ENTRY.IP], eax	    ; ebx=ARPTable base
    loopnz  @b			     ; Return back if non match
    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]
 
    DEBUGF 1,"MAC found:  %x-%x-%x-%x-%x-%x status:%x in slot:%u\n",\
    [ebx + esi + ARP_ENTRY.MAC]:2,[ebx + esi + ARP_ENTRY.MAC+1]:2,[ebx + esi + ARP_ENTRY.MAC+2]:2,[ebx + esi + ARP_ENTRY.MAC+3]:2,[ebx + esi + ARP_ENTRY.MAC+4]:2,[ebx + esi + ARP_ENTRY.MAC+5]:2, ax, esi
 
    ; esi holds index
    cld
    lea     esi, [ebx + esi + ARP_ENTRY.MAC]
    mov     edi, [Extra]   ;edi=ptr to buffer for write MAC
    movsd
    movsw
    jmp     .exit
 
  .ip_to_mac_send_request:
;;; TODO: get device number ! (in edx)
    xor     edx, edx
    mov     edx, [ETH_DRV_LIST + 4*edx]
    lea     ecx, [edx + ETH_DEVICE.mac]
 
    stdcall arp_request,[Index],[IP_LIST+edx],ecx  ;TargetIP,SenderIP_ptr,SenderMAC_ptr
    mov     eax, ARP_NO_ENTRY
    jmp     .exit
 
;;END IP_TO_MAC
 
;;BEGIN GET_ENTRIES_NUMBER
;;Description: returns an ARP-entries number in the ARPTable
;;IN:   Operation: ARP_TABLE_GET_ENTRIES_NUMBER
;;      Index: must be zero
;;      Extra: must be zero
;;OUT:
;;  EAX=ARP-entries number in the ARPTable
  .get_entries_number:
    mov     eax, dword[NumARP]
    jmp     .exit
;;END GET_ENTRIES_NUMBER
 
.exit:
    ret
endp
 
 
;***************************************************************************
;   Function
;      arp_request  [by Johnny_B]
;
;   Description
;      Sends an ARP request on the ethernet
;   IN:
;     TargetIP      : requested IP address
;     SenderIP_ptr  : POINTER to sender's IP address(our system's address)
;     SenderMAC_ptr : POINTER to sender's MAC address(our system's address)
;   OUT:
;     EAX=0 (if all is ok), otherwise EAX is not defined
;
;      EBX,ESI,EDI will be saved
;
;***************************************************************************
proc arp_request stdcall uses ebx esi edi,\
    TargetIP:DWORD, SenderIP_ptr:DWORD, SenderMAC_ptr:DWORD
 
    DEBUGF 1,"Create ARP request\n"
 
 
    stdcall kernel_alloc, 60  ; minimum eth packet size
    test    eax, eax
    jz	    .exit
 
    mov     ebx, eax
 
    mov     word [ebx + ETH_FRAME.Data + ARP_Packet.HardwareType], 0x0100 ;Ethernet
    mov     word [ebx + ETH_FRAME.Data + ARP_Packet.ProtocolType], 0x0008 ;IP
    mov     byte [ebx + ETH_FRAME.Data + ARP_Packet.HardwareSize], 0x06   ;MAC-addr length
    mov     byte [ebx + ETH_FRAME.Data + ARP_Packet.ProtocolSize], 0x04   ;IP-addr length
    mov     word [ebx + ETH_FRAME.Data + ARP_Packet.Opcode], 0x0100	  ;Request
 
    DEBUGF 1,"1"
 
    cld
    mov     esi, [SenderMAC_ptr]
    lea     edi, [ebx + ETH_FRAME.Data + ARP_Packet.SenderMAC]	     ;Our MAC-addr
    movsd
    movsw
 
    DEBUGF 1,"2"
 
    mov     esi, [SenderIP_ptr]
    mov     [ebx + ETH_FRAME.Data + ARP_Packet.SenderIP], esi	     ;Our IP-addr
;    movsd
 
    DEBUGF 1,"3"
 
    lea     edi, [ebx + ETH_FRAME.Data + ARP_Packet.TargetMAC]	     ; Required MAC-addr
    xor     eax, eax
    stosd
    stosw
 
    DEBUGF 1,"4"
 
    lea     edi, [ebx + ETH_FRAME.DstMAC]
    stosd
    stosw
 
    DEBUGF 1,"5"
 
    mov     esi, [TargetIP]
    mov     dword [ebx + ETH_FRAME.Data + ARP_Packet.TargetIP], esi   ;Required IP-addr(we get it as function parameter)
 
 
    DEBUGF 1,"6"
 
    mov     esi, [SenderMAC_ptr]
    lea     edi, [ebx + ETH_FRAME.SrcMAC]
    movsd
    movsw
 
    DEBUGF 1,"7"
 
    mov     ax , ETHER_ARP
    stosw
 
    DEBUGF 1,"8"
 
;;; TODO: get device number in edx !!
    xor     edx, edx
    shl     edx, 2
 
    inc     [ARP_PACKETS_TX+edx]
 
    push    dword .returnaddr
    push    dword 60
    push    ebx
    mov     ebx, [ETH_DRV_LIST + edx]
    jmp     [ebx + ETH_DEVICE.transmit]
.returnaddr:
 
    ; Add an entry in the ARP table, awaiting response
    sub     esp, ARP_ENTRY.size    ;allocate memory for ARP-entry
 
    mov     esi, dword[TargetIP]
    mov     dword[esp + ARP_ENTRY.IP],esi
 
    lea     edi, [esp + ARP_ENTRY.MAC]
    xor     eax, eax
    stosd
    stosw
 
    mov     word[esp + ARP_ENTRY.Status], ARP_AWAITING_RESPONSE
    mov     word[esp + ARP_ENTRY.TTL], 10  ; 10 seconds
 
    stdcall arp_table_manager,ARP_TABLE_ADD,EXTRA_IS_ARP_ENTRY_PTR,esp
    add     esp, ARP_ENTRY.size ; free memory
 
.exit:
 
    DEBUGF 1,"ARP request - end\n"
    ret
endp
 
 
 
 
 
;---------------------------------------------------------------------------
;
; ARP_decrease_entry_ttls
;
; IN: /
; OUT: /
;
;---------------------------------------------------------------------------
 
align 4
ARP_decrease_entry_ttls:
 
	mov	ecx, [NumARP]
	test	ecx, ecx
	jz	.exit
 
	mov	ebx, ARPTable
 
.timer_loop:
 
	movsx	esi, word [ebx + ARP_ENTRY.TTL]
	cmp	esi, 0xFFFFFFFF
	je	.timer_loop_end  ;if TTL==0xFFFF then it's static entry
 
	test	esi, esi
	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
	jne	@f
 
	mov	word [ebx + ARP_ENTRY.Status], ARP_RESPONSE_TIMEOUT
	mov	word [ebx + ARP_ENTRY.TTL], word 0x000A   ;10 sec
	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]
	sub	esi, ecx	  ;esi=index of entry, will be deleted
 
	call	ARP_del_entry
 
	jmp	.timer_loop_end
 
 
.timer_loop_end_with_dec:
 
	dec	word [ebx + ARP_ENTRY.TTL]  ;decrease TTL
 
.timer_loop_end:
 
	add	ebx, ARP_ENTRY.size
	loop	.timer_loop
 
.exit:
 
	ret
 
 
;---------------------------------------------------------------------------
;
; ARP_del_entry
;
; IN: entry # in esi
; OUT: /
;
;---------------------------------------------------------------------------
 
align 4
ARP_del_entry:
 
	imul	esi, ARP_ENTRY.size
 
	mov	ecx, (ARP_TABLE_SIZE - 1) * ARP_ENTRY.size
	sub	ecx, esi
 
	lea	edi, [ebx + esi]	    ;edi=ptr to entry that should be deleted
	lea	esi, [edi + ARP_ENTRY.size] ;esi=ptr to next entry
 
	shr	ecx,1	   ;ecx/2 => ARP_ENTRY_SIZE MUST BE EVEN NUMBER!
	cld
	rep	movsw
 
	dec	dword[NumARP] ;decrease arp-entries counter
	ret
 
 
 
 
 
;-----------------------------------------------------
;
; ARP_Handler:
;
;  This function handles ARP protocol over ethernet
;  (other protocols may follow in the future)
;
;  IN:  Pointer to buffer in [esp]
;       size of buffer in [esp+4]
;       packet size (without ethernet header) in ecx
;  OUT: /
;
;-----------------------------------------------------
align 4
ARP_Handler:
 
	DEBUGF	1,"ARP_Handler - start\n"
	cmp	ecx, 28
	jl	.exit
 
; 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
 
;        push    ebx edx
	stdcall arp_table_manager, ARP_TABLE_ADD, EXTRA_IS_ARP_PACKET_PTR, edx
;        pop     edx ebx
 
	cmp	word [edx + ARP_Packet.Opcode], ARP_REQ_OPCODE	; Is this a request packet?
	jne	.exit
 
	call	ETH_struc2dev
	DEBUGF	1,"ARP Packet came from device: %u\n", edi
	inc	[ARP_PACKETS_RX+4*edi]
	cmp	edi, -1
	jz	.exit
 
	mov	eax, edi
	shl	eax, 2
	add	eax, IP_LIST
	mov	eax, [eax]
	cmp	eax, [edx + ARP_Packet.TargetIP]		; Is it looking for my IP address?
	jnz	.exit
	push	eax
	push	edi
 
;        DEBUGF  1,"ETH_ARP_Handler - request for %u.%u.%u.%u\n",[edi+0]:1,[edi+1]:1,[edi+2]:1,[edi+3]:1
 
; OK, it is a request for one of our MAC addresses. Build the frame and send it
; We can reuse the buffer.
 
	cld
	lea	esi, [edx + ARP_Packet.SenderMAC]
	lea	edi, [edx + ARP_Packet.TargetMAC]
	movsd							; Move Sender Mac to Dest MAC
	movsw							;
	movsd							; Move sender IP to Dest IP
 
	pop	esi
	mov	esi, [ETH_DRV_LIST + 4*esi]
	lea	esi, [esi + ETH_DEVICE.mac]
	lea	edi, [edx + ARP_Packet.SenderMAC]
	movsd							; Copy MAC address from in MAC_LIST
	movsw							;
	pop	eax
	stosd							; Write our IP
 
	mov	word [edx + ARP_Packet.Opcode], ARP_REP_OPCODE
 
; Now, Fill in ETHERNET header
 
	mov	edi, [esp]
	lea	esi, [edx + ARP_Packet.TargetMAC]
	movsd
	movsw
	lea	esi, [edx + ARP_Packet.SenderMAC]
	movsd
	movsw
	mov	ax , ETHER_ARP
	stosw
 
	jmp	ETH_Sender					; And send it!
 
       .exit:
	call	kernel_free
	add	esp, 4						; pop (balance stack)
 
	DEBUGF 1,"ARP_Handler - fail\n"
	ret
 
 
 
 
;---------------------------------------------------------------------------
;
; ARP_API
;
; This function is called by system function 75
;
; IN:  subfunction number in bl
;      device number in bh
;      ecx, edx, .. depends on subfunction
;
; OUT:
;
;---------------------------------------------------------------------------
 
align 4
ARP_API:
 
	movzx	eax, bh
	shl	eax, 2
 
	test	bl, bl
	jz	.packets_tx	; 0
	dec	bl
	jz	.packets_rx	; 1
	dec	bl
	jz	.entries	; 2
	dec	bl
	jz	.read		; 3
	dec	bl
	jz	.write		; 4
	dec	bl
	jz	.remove 	; 5
	dec	bl
 
 
.error:
	mov	eax, -1
	ret
 
.packets_tx:
	add	eax, ARP_PACKETS_TX
	mov	eax, [eax]
	ret
 
.packets_rx:
	add	eax, ARP_PACKETS_RX
	mov	eax, [eax]
	ret
 
.entries:
	mov	eax, [NumARP]
	ret
 
.read:
	; TODO: write code
	ret
 
.write:
	; TODO: write code
	ret
 
.remove:
	; TODO: write code
	ret

Rev 1171	Rev 1185
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2008. 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	;; Address Resolution Protocol ;;	8	;; Address Resolution Protocol ;;
9	;; ;;	9	;; ;;
10	;; This file contains the following: ;;	10	;; This file contains the following: ;;
11	;; arp_table_manager - Manages an ARPTable ;;	11	;; arp_table_manager - Manages an ARPTable ;;
12	;; arp_request - Sends an ARP request on the ethernet ;;	12	;; arp_request - Sends an ARP request on the ethernet ;;
13	;; arp_handler - Called when an ARP packet is received ;;	13	;; arp_handler - Called when an ARP packet is received ;;
14	;; ;;	14	;; ;;
15	;; Changes history: ;;	15	;; Changes history: ;;
16	;; 22.09.2003 - [Mike Hibbett] : mikeh@oceanfree.net ;;	16	;; 22.09.2003 - [Mike Hibbett] : mikeh@oceanfree.net ;;
17	;; 11.11.2006 - [Johnny_B] and [smb] ;;	17	;; 11.11.2006 - [Johnny_B] and [smb] ;;
18	;; ;;	18	;; ;;
19	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	19	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
20		20
21	$Revision: 983 $	21	$Revision: 983 $
22		22
23		23
24	ARP_NO_ENTRY equ 0	24	ARP_NO_ENTRY equ 0
25	ARP_VALID_MAPPING equ 1	25	ARP_VALID_MAPPING equ 1
26	ARP_AWAITING_RESPONSE equ 2	26	ARP_AWAITING_RESPONSE equ 2
27	ARP_RESPONSE_TIMEOUT equ 3	27	ARP_RESPONSE_TIMEOUT equ 3
28		28
29	ETHER_ARP equ 0x0608	29	ETHER_ARP equ 0x0608
30		30
31	ARP_REQ_OPCODE equ 0x0100 ; request	31	ARP_REQ_OPCODE equ 0x0100 ; request
32	ARP_REP_OPCODE equ 0x0200 ; reply	32	ARP_REP_OPCODE equ 0x0200 ; reply
33		33
34	ARP_TABLE_SIZE equ 20 ; Size of table	34	ARP_TABLE_SIZE equ 20 ; Size of table
35		35
36	struct ARP_ENTRY	36	struct ARP_ENTRY
37	.IP dd ?	37	.IP dd ?
38	.MAC dp ?	38	.MAC dp ?
39	.Status dw ?	39	.Status dw ?
40	.TTL dw ? ; in seconds	40	.TTL dw ? ; in seconds
41	.size:	41	.size:
42	ends	42	ends
43		43
44	struct ARP_Packet	44	struct ARP_Packet
45	.HardwareType dw ?	45	.HardwareType dw ?
46	.ProtocolType dw ?	46	.ProtocolType dw ?
47	.HardwareSize db ?	47	.HardwareSize db ?
48	.ProtocolSize db ?	48	.ProtocolSize db ?
49	.Opcode dw ?	49	.Opcode dw ?
50	.SenderMAC dp ?	50	.SenderMAC dp ?
51	.SenderIP dd ?	51	.SenderIP dd ?
52	.TargetMAC dp ?	52	.TargetMAC dp ?
53	.TargetIP dd ?	53	.TargetIP dd ?
54	ends	54	ends
55		55
56		56
57	; The TTL field is decremented every second, and is deleted when it	57	; The TTL field is decremented every second, and is deleted when it
58	; reaches 0. It is refreshed every time a packet is received	58	; reaches 0. It is refreshed every time a packet is received
59	; If the TTL field is 0xFFFF it is a static entry and is never deleted	59	; If the TTL field is 0xFFFF it is a static entry and is never deleted
60	; The status field can be the following values:	60	; The status field can be the following values:
61	; 0x0000 entry not used	61	; 0x0000 entry not used
62	; 0x0001 entry holds a valid mapping	62	; 0x0001 entry holds a valid mapping
63	; 0x0002 entry contains an IP address, awaiting ARP response	63	; 0x0002 entry contains an IP address, awaiting ARP response
64	; 0x0003 No response received to ARP request.	64	; 0x0003 No response received to ARP request.
65	; The last status value is provided to allow the network layer to delete	65	; The last status value is provided to allow the network layer to delete
66	; a packet that is queued awaiting an ARP response	66	; a packet that is queued awaiting an ARP response
67		67
68	align 4	68	align 4
69	uglobal	69	uglobal
70		70
71	NumARP dd ?	71	NumARP dd ?
72	ARPTable rb ARP_ENTRY.size * ARP_TABLE_SIZE	72	ARPTable rb ARP_ENTRY.size * ARP_TABLE_SIZE
73		73
74	ARP_PACKETS_TX rd MAX_NET_DEVICES	74	ARP_PACKETS_TX rd MAX_NET_DEVICES
75	ARP_PACKETS_RX rd MAX_NET_DEVICES	75	ARP_PACKETS_RX rd MAX_NET_DEVICES
76		76
77		77
78	endg	78	endg
79		79
80		80
81		81
82		82
83	ARP_init:	83	ARP_init:
84		84
85	xor eax, eax	85	xor eax, eax
86		86
87	mov [NumARP], eax	87	mov [NumARP], eax
88		88
89	mov edi, ARP_PACKETS_TX	89	mov edi, ARP_PACKETS_TX
90	mov ecx, 2*MAX_NET_DEVICES	90	mov ecx, 2*MAX_NET_DEVICES
91	rep stosd	91	rep stosd
92		92
93	ret	93	ret
94		94
95		95
96		96
97		97
98	;***************************************************************************	98	;***************************************************************************
99	; Function	99	; Function
100	; arp_table_manager [by Johnny_B]	100	; arp_table_manager [by Johnny_B]
101	;	101	;
102	; Description	102	; Description
103	; Does a most required operations with ARP-table	103	; Does a most required operations with ARP-table
104	; IN:	104	; IN:
105	; Operation: see Opcode's constants below	105	; Operation: see Opcode's constants below
106	; Index: Index of entry in the ARP-table	106	; Index: Index of entry in the ARP-table
107	; Extra: Extra parameter for some Opcodes	107	; Extra: Extra parameter for some Opcodes
108	; OUT:	108	; OUT:
109	; EAX = Returned value depends on opcodes, more detailed see below	109	; EAX = Returned value depends on opcodes, more detailed see below
110	;	110	;
111	;***************************************************************************	111	;***************************************************************************
112	;Opcode's constants	112	;Opcode's constants
113	ARP_TABLE_ADD equ 1	113	ARP_TABLE_ADD equ 1
114	ARP_TABLE_DEL equ 2	114	ARP_TABLE_DEL equ 2
115	ARP_TABLE_GET equ 3	115	ARP_TABLE_GET equ 3
116	ARP_TABLE_GET_ENTRIES_NUMBER equ 4	116	ARP_TABLE_GET_ENTRIES_NUMBER equ 4
117	ARP_TABLE_IP_TO_MAC equ 5	117	ARP_TABLE_IP_TO_MAC equ 5
118	ARP_TABLE_TIMER equ 6	118	ARP_TABLE_TIMER equ 6
119		119
120	;Index's constants	120	;Index's constants
121	EXTRA_IS_ARP_PACKET_PTR equ 0 ;if Extra contain pointer to ARP_Packet	121	EXTRA_IS_ARP_PACKET_PTR equ 0 ;if Extra contain pointer to ARP_Packet
122	EXTRA_IS_ARP_ENTRY_PTR equ -1 ;if Extra contain pointer to ARP_ENTRY	122	EXTRA_IS_ARP_ENTRY_PTR equ -1 ;if Extra contain pointer to ARP_ENTRY
123		123
124	align 4	124	align 4
125	proc arp_table_manager stdcall uses ebx esi edi ecx edx, Opcode:DWORD,Index:DWORD,Extra:DWORD	125	proc arp_table_manager stdcall uses ebx esi edi ecx edx, Opcode:DWORD,Index:DWORD,Extra:DWORD
126		126
127	mov ebx, ARPTable ;ARPTable base	127	mov ebx, ARPTable ;ARPTable base
128	mov ecx, dword[NumARP] ;ARP-entries counter	128	mov ecx, dword[NumARP] ;ARP-entries counter
129		129
130	mov eax, dword[Opcode]	130	mov eax, dword[Opcode]
131		131
132	cmp eax, ARP_TABLE_TIMER	132	cmp eax, ARP_TABLE_TIMER
133	je .timer	133	je .timer
134		134
135	DEBUGF 1,"ARP table manager opcode:%u numARP:%u\n",eax,ecx	135	DEBUGF 1,"ARP table manager opcode:%u numARP:%u\n",eax,ecx
136		136
137	cmp eax, ARP_TABLE_ADD	137	cmp eax, ARP_TABLE_ADD
138	je .add	138	je .add
139	cmp eax, ARP_TABLE_DEL	139	cmp eax, ARP_TABLE_DEL
140	je .del	140	je .del
141	cmp eax, ARP_TABLE_GET	141	cmp eax, ARP_TABLE_GET
142	je .get	142	je .get
143	cmp eax, ARP_TABLE_IP_TO_MAC	143	cmp eax, ARP_TABLE_IP_TO_MAC
144	je .ip_to_mac	144	je .ip_to_mac
145	cmp eax, ARP_TABLE_GET_ENTRIES_NUMBER	145	cmp eax, ARP_TABLE_GET_ENTRIES_NUMBER
146	je .get_entries_number	146	je .get_entries_number
147	jmp .exit ;if unknown opcode	147	jmp .exit ;if unknown opcode
148		148
149		149
150	;;BEGIN TIMER	150	;;BEGIN TIMER
151	;;Description: it must be callback every second. It is responsible for removing expired routes.	151	;;Description: it must be callback every second. It is responsible for removing expired routes.
152	;;IN: Operation: ARP_TABLE_TIMER	152	;;IN: Operation: ARP_TABLE_TIMER
153	;; Index: must be zero	153	;; Index: must be zero
154	;; Extra: must be zero	154	;; Extra: must be zero
155	;;OUT:	155	;;OUT:
156	;; EAX=not defined	156	;; EAX=not defined
157	;;	157	;;
158	.timer:	158	.timer:
159	test ecx, ecx	159	test ecx, ecx
160	jz .exit ;if NumARP=0 nothing to do	160	jz .exit ;if NumARP=0 nothing to do
161	; sub ecx, ARP_TABLE_ENTRIES ;ecx=dynamic entries number	161	; sub ecx, ARP_TABLE_ENTRIES ;ecx=dynamic entries number
162	; jz .exit ;if NumARP=number of static entries then exit	162	; jz .exit ;if NumARP=number of static entries then exit
163		163
164	; add ebx, ARP_TABLE_ENTRIES*ARP_ENTRY_SIZE ;ebx=dynamic entries base	164	; add ebx, ARP_TABLE_ENTRIES*ARP_ENTRY_SIZE ;ebx=dynamic entries base
165		165
166	.timer_loop:	166	.timer_loop:
167	movsx esi, word [ebx + ARP_ENTRY.TTL]	167	movsx esi, word [ebx + ARP_ENTRY.TTL]
168	cmp esi, 0xFFFFFFFF	168	cmp esi, 0xFFFFFFFF
169	je .timer_loop_end ;if TTL==0xFFFF then it's static entry	169	je .timer_loop_end ;if TTL==0xFFFF then it's static entry
170		170
171	test esi, esi	171	test esi, esi
172	jnz .timer_loop_end_with_dec ;if TTL!=0	172	jnz .timer_loop_end_with_dec ;if TTL!=0
173		173
174	; Ok, TTL is 0	174	; Ok, TTL is 0
175	;if Status==AWAITING_RESPONSE and TTL==0	175	;if Status==AWAITING_RESPONSE and TTL==0
176	;then we have to change it to ARP_RESPONSE_TIMEOUT	176	;then we have to change it to ARP_RESPONSE_TIMEOUT
177	cmp word [ebx + ARP_ENTRY.Status], ARP_AWAITING_RESPONSE	177	cmp word [ebx + ARP_ENTRY.Status], ARP_AWAITING_RESPONSE
178	jne @f	178	jne @f
179		179
180	mov word [ebx + ARP_ENTRY.Status], ARP_RESPONSE_TIMEOUT	180	mov word [ebx + ARP_ENTRY.Status], ARP_RESPONSE_TIMEOUT
181	mov word [ebx + ARP_ENTRY.TTL], word 0x000A ;10 sec	181	mov word [ebx + ARP_ENTRY.TTL], word 0x000A ;10 sec
182	jmp .timer_loop_end	182	jmp .timer_loop_end
183		183
184	@@:	184	@@:
185	;if TTL==0 and Status==VALID_MAPPING, we have to delete it	185	;if TTL==0 and Status==VALID_MAPPING, we have to delete it
186	;if TTL==0 and Status==RESPONSE_TIMEOUT, delete too	186	;if TTL==0 and Status==RESPONSE_TIMEOUT, delete too
187	mov esi, dword[NumARP]	187	mov esi, dword[NumARP]
188	sub esi, ecx ;esi=index of entry, will be deleted	188	sub esi, ecx ;esi=index of entry, will be deleted
189	stdcall arp_table_manager,ARP_TABLE_DEL,esi,0 ;opcode,index,extra	189	stdcall arp_table_manager,ARP_TABLE_DEL,esi,0 ;opcode,index,extra
190	jmp .timer_loop_end	190	jmp .timer_loop_end
191		191
192		192
193	.timer_loop_end_with_dec:	193	.timer_loop_end_with_dec:
194	dec word [ebx + ARP_ENTRY.TTL] ;decrease TTL	194	dec word [ebx + ARP_ENTRY.TTL] ;decrease TTL
195	.timer_loop_end:	195	.timer_loop_end:
196	add ebx, ARP_ENTRY.size	196	add ebx, ARP_ENTRY.size
197	loop .timer_loop	197	loop .timer_loop
198		198
199	jmp .exit	199	jmp .exit
200	;;END TIMER	200	;;END TIMER
201		201
202	;;BEGIN ADD	202	;;BEGIN ADD
203	;;Description: it adds an entry in the table. If ARP-table already	203	;;Description: it adds an entry in the table. If ARP-table already
204	;; contains same IP, it will be updated.	204	;; contains same IP, it will be updated.
205	;;IN: Operation: ARP_TABLE_ADD	205	;;IN: Operation: ARP_TABLE_ADD
206	;; Index: specifies what contains Extra-parameter	206	;; Index: specifies what contains Extra-parameter
207	;; Extra: if Index==EXTRA_IS_ARP_Packet_PTR,	207	;; Extra: if Index==EXTRA_IS_ARP_Packet_PTR,
208	;; then Extra contains pointer to ARP_Packet,	208	;; then Extra contains pointer to ARP_Packet,
209	;; otherwise Extra contains pointer to ARP_ENTRY	209	;; otherwise Extra contains pointer to ARP_ENTRY
210	;;OUT:	210	;;OUT:
211	;; EAX=index of entry, that has been added	211	;; EAX=index of entry, that has been added
212	;;	212	;;
213	.add:	213	.add:
214		214
215	DEBUGF 1,"1"	215	DEBUGF 1,"1"
216		216
217	sub esp, ARP_ENTRY.size ;Allocate ARP_ENTRY_SIZE byte in stack	217	sub esp, ARP_ENTRY.size ;Allocate ARP_ENTRY_SIZE byte in stack
218		218
219	mov esi, [Extra] ;pointer	219	mov esi, [Extra] ;pointer
220	mov edi, [Index] ;opcode	220	mov edi, [Index] ;opcode
221		221
222	cmp edi, EXTRA_IS_ARP_PACKET_PTR	222	cmp edi, EXTRA_IS_ARP_PACKET_PTR
223	je .ARP_Packet_to_entry ;if Extra contain ptr to ARP_Packet and we have to form arp-entry	223	je .ARP_Packet_to_entry ;if Extra contain ptr to ARP_Packet and we have to form arp-entry
224	;else it contain ptr to arp-entry	224	;else it contain ptr to arp-entry
225		225
226	DEBUGF 1,"2"	226	DEBUGF 1,"2"
227		227
228	cld	228	cld
229	; esi already has been loaded	229	; esi already has been loaded
230	mov edi, esp ;ebx + eax=ARPTable_base + ARP-entry_base(where we will add)	230	mov edi, esp ;ebx + eax=ARPTable_base + ARP-entry_base(where we will add)
231	mov ecx,ARP_ENTRY.size/2 ;ARP_ENTRY_SIZE must be even number!!!	231	mov ecx,ARP_ENTRY.size/2 ;ARP_ENTRY_SIZE must be even number!!!
232	rep movsw ;copy	232	rep movsw ;copy
233	jmp .search	233	jmp .search
234		234
235	.ARP_Packet_to_entry:	235	.ARP_Packet_to_entry:
236		236
237	DEBUGF 1,"3"	237	DEBUGF 1,"3"
238	mov edx, dword[esi + ARP_Packet.SenderIP] ;esi=base of ARP_Packet	238	mov edx, dword[esi + ARP_Packet.SenderIP] ;esi=base of ARP_Packet
239	mov [esp + ARP_ENTRY.IP], edx	239	mov [esp + ARP_ENTRY.IP], edx
240		240
241	cld	241	cld
242	lea esi, [esi + ARP_Packet.SenderMAC]	242	lea esi, [esi + ARP_Packet.SenderMAC]
243	lea edi, [esp + ARP_ENTRY.MAC]	243	lea edi, [esp + ARP_ENTRY.MAC]
244	movsd	244	movsd
245	movsw	245	movsw
246	mov word[esp + ARP_ENTRY.Status], ARP_VALID_MAPPING ; specify the type - a valid entry	246	mov word[esp + ARP_ENTRY.Status], ARP_VALID_MAPPING ; specify the type - a valid entry
247	mov word[esp + ARP_ENTRY.TTL], 0x0E10 ; = 1 hour	247	mov word[esp + ARP_ENTRY.TTL], 0x0E10 ; = 1 hour
248		248
249	.search:	249	.search:
250		250
251	DEBUGF 1,"4"	251	DEBUGF 1,"4"
252	mov edx, dword[esp + ARP_ENTRY.IP] ;edx=IP-address, which we'll search	252	mov edx, dword[esp + ARP_ENTRY.IP] ;edx=IP-address, which we'll search
253	mov ecx, dword[NumARP] ;ecx=ARP-entries counter	253	mov ecx, dword[NumARP] ;ecx=ARP-entries counter
254	jecxz .add_to_end ;if ARP-entries number == 0	254	jecxz .add_to_end ;if ARP-entries number == 0
255	imul eax, ecx, ARP_ENTRY.size ;eax=current table size(in bytes)	255	imul eax, ecx, ARP_ENTRY.size ;eax=current table size(in bytes)
256	@@:	256	@@:
257	sub eax, ARP_ENTRY.size	257	sub eax, ARP_ENTRY.size
258	cmp dword[ebx + eax + ARP_ENTRY.IP], edx	258	cmp dword[ebx + eax + ARP_ENTRY.IP], edx
259	loopnz @b	259	loopnz @b
260	; jz .replace ; found, replace existing entry, ptr to it is in eax	260	; jz .replace ; found, replace existing entry, ptr to it is in eax
261		261
262	.add_to_end:	262	.add_to_end:
263	;	263	;
264	; DEBUGF 1,"5\n"	264	; DEBUGF 1,"5\n"
265	; ;else add to end	265	; ;else add to end
266	; or eax,-1 ;set eax=0xFFFFFFFF if adding is impossible	266	; or eax,-1 ;set eax=0xFFFFFFFF if adding is impossible
267	; mov ecx, dword[NumARP]	267	; mov ecx, dword[NumARP]
268	; cmp ecx, ARP_TABLE_SIZE	268	; cmp ecx, ARP_TABLE_SIZE
269	; je .add_exit ;if arp-entries number is equal to arp-table maxsize	269	; je .add_exit ;if arp-entries number is equal to arp-table maxsize
270		270
271	; imul eax, dword[NumARP], ARP_ENTRY.size ;eax=ptr to end of ARPTable	271	; imul eax, dword[NumARP], ARP_ENTRY.size ;eax=ptr to end of ARPTable
272	; inc dword [NumARP] ;increase ARP-entries counter	272	; inc dword [NumARP] ;increase ARP-entries counter
273		273
274	; .replace:	274	; .replace:
275	DEBUGF 1,"Updating ARP entry: %x-%x-%x-%x-%x-%x = %u.%u.%u.%u to slot:%u\n",\	275	DEBUGF 1,"Updating ARP entry: %x-%x-%x-%x-%x-%x = %u.%u.%u.%u to slot:%u\n",\
276	[esp + ARP_ENTRY.MAC]:2,[esp + ARP_ENTRY.MAC+1]:2,[esp + ARP_ENTRY.MAC+2]:2,[esp + ARP_ENTRY.MAC+3]:2,[esp + ARP_ENTRY.MAC+4]:2,[esp + ARP_ENTRY.MAC+5]:2,\	276	[esp + ARP_ENTRY.MAC]:2,[esp + ARP_ENTRY.MAC+1]:2,[esp + ARP_ENTRY.MAC+2]:2,[esp + ARP_ENTRY.MAC+3]:2,[esp + ARP_ENTRY.MAC+4]:2,[esp + ARP_ENTRY.MAC+5]:2,\
277	[esp + ARP_ENTRY.IP]:1,[esp + ARP_ENTRY.IP+1]:1,[esp + ARP_ENTRY.IP+2]:1,[esp + ARP_ENTRY.IP+3]:1,eax	277	[esp + ARP_ENTRY.IP]:1,[esp + ARP_ENTRY.IP+1]:1,[esp + ARP_ENTRY.IP+2]:1,[esp + ARP_ENTRY.IP+3]:1,eax
278		278
279	cld	279	cld
280	mov esi, esp ;esp=base of ARP-entry, that will be added	280	mov esi, esp ;esp=base of ARP-entry, that will be added
281	lea edi, [ebx + eax] ;ebx + eax=ARPTable_base + ARP-entry_base(where we will add)	281	lea edi, [ebx + eax] ;ebx + eax=ARPTable_base + ARP-entry_base(where we will add)
282	mov ecx,ARP_ENTRY.size/2 ;ARP_ENTRY_SIZE must be even number!!!	282	mov ecx,ARP_ENTRY.size/2 ;ARP_ENTRY_SIZE must be even number!!!
283	rep movsw	283	rep movsw
284		284
285	mov ecx, ARP_ENTRY.size	285	mov ecx, ARP_ENTRY.size
286	xor edx, edx ;"div" takes operand from EDX:EAX	286	xor edx, edx ;"div" takes operand from EDX:EAX
287	div ecx ;eax=index of entry, which has been added	287	div ecx ;eax=index of entry, which has been added
288		288
289		289
290		290
291	.add_exit:	291	.add_exit:
292		292
293	add esp, ARP_ENTRY.size ;free stack	293	add esp, ARP_ENTRY.size ;free stack
294	jmp .exit	294	jmp .exit
295	;;END ADD	295	;;END ADD
296		296
297	;;BEGIN DEL	297	;;BEGIN DEL
298	;;Description: it deletes an entry in the table.	298	;;Description: it deletes an entry in the table.
299	;;IN: Operation: ARP_TABLE_DEL	299	;;IN: Operation: ARP_TABLE_DEL
300	;; Index: index of entry, that should be deleted	300	;; Index: index of entry, that should be deleted
301	;; Extra: must be zero	301	;; Extra: must be zero
302	;;OUT:	302	;;OUT:
303	;; EAX=not defined	303	;; EAX=not defined
304	;;	304	;;
305	.del:	305	.del:
306	mov esi, [Index]	306	mov esi, [Index]
307	imul esi, ARP_ENTRY.size	307	imul esi, ARP_ENTRY.size
308		308
309	mov ecx, (ARP_TABLE_SIZE - 1) * ARP_ENTRY.size	309	mov ecx, (ARP_TABLE_SIZE - 1) * ARP_ENTRY.size
310	sub ecx, esi	310	sub ecx, esi
311		311
312	lea edi, [ebx + esi] ;edi=ptr to entry that should be deleted	312	lea edi, [ebx + esi] ;edi=ptr to entry that should be deleted
313	lea esi, [edi + ARP_ENTRY.size] ;esi=ptr to next entry	313	lea esi, [edi + ARP_ENTRY.size] ;esi=ptr to next entry
314		314
315	shr ecx,1 ;ecx/2 => ARP_ENTRY_SIZE MUST BE EVEN NUMBER!	315	shr ecx,1 ;ecx/2 => ARP_ENTRY_SIZE MUST BE EVEN NUMBER!
316	cld	316	cld
317	rep movsw	317	rep movsw
318		318
319	dec dword[NumARP] ;decrease arp-entries counter	319	dec dword[NumARP] ;decrease arp-entries counter
320	jmp .exit	320	jmp .exit
321	;;END DEL	321	;;END DEL
322		322
323	;;BEGIN GET	323	;;BEGIN GET
324	;;Description: it reads an entry of table into buffer.	324	;;Description: it reads an entry of table into buffer.
325	;;IN: Operation: ARP_TABLE_GET	325	;;IN: Operation: ARP_TABLE_GET
326	;; Index: index of entry, that should be read	326	;; Index: index of entry, that should be read
327	;; Extra: pointer to buffer for reading(size must be equal to ARP_ENTRY_SIZE)	327	;; Extra: pointer to buffer for reading(size must be equal to ARP_ENTRY_SIZE)
328	;;OUT:	328	;;OUT:
329	;; EAX=not defined	329	;; EAX=not defined
330	;;	330	;;
331	.get:	331	.get:
332	mov esi, [Index]	332	mov esi, [Index]
333	imul esi, ARP_ENTRY.size ;esi=ptr to required ARP_ENTRY	333	imul esi, ARP_ENTRY.size ;esi=ptr to required ARP_ENTRY
334	mov edi, [Extra] ;edi=buffer for reading	334	mov edi, [Extra] ;edi=buffer for reading
335	mov ecx, ARP_ENTRY.size/2 ; must be even number!!!	335	mov ecx, ARP_ENTRY.size/2 ; must be even number!!!
336	cld	336	cld
337	rep movsw	337	rep movsw
338	jmp .exit	338	jmp .exit
339	;;END GET	339	;;END GET
340		340
341	;;BEGIN IP_TO_MAC	341	;;BEGIN IP_TO_MAC
342	;;Description: it gets an IP from Index, scans each entry in the table and writes	342	;;Description: it gets an IP from Index, scans each entry in the table and writes
343	;; MAC, that relates to specified IP, into buffer specified in Extra.	343	;; MAC, that relates to specified IP, into buffer specified in Extra.
344	;; And if it cannot find an IP-address in the table, it does an ARP-request of that.	344	;; And if it cannot find an IP-address in the table, it does an ARP-request of that.
345	;;IN: Operation: ARP_TABLE_IP_TO_MAC	345	;;IN: Operation: ARP_TABLE_IP_TO_MAC
346	;; Index: IP that should be transformed into MAC	346	;; Index: IP that should be transformed into MAC
347	;; Extra: pointer to buffer where will be written the MAC-address.	347	;; Extra: pointer to buffer where will be written the MAC-address.
348	;;OUT:	348	;;OUT:
349	;; EAX=ARP table entry status code.	349	;; EAX=ARP table entry status code.
350	;; If EAX==ARP_NO_ENTRY, IP isn't found in the table and we have sent the request.	350	;; If EAX==ARP_NO_ENTRY, IP isn't found in the table and we have sent the request.
351	;; If EAX==ARP_AWAITING_RESPONSE, we wait the response from remote system.	351	;; If EAX==ARP_AWAITING_RESPONSE, we wait the response from remote system.
352	;; If EAX==ARP_RESPONSE_TIMEOUT, remote system not responds too long.	352	;; If EAX==ARP_RESPONSE_TIMEOUT, remote system not responds too long.
353	;; If EAX==ARP_VALID_MAPPING, all is ok, we've got a true MAC.	353	;; If EAX==ARP_VALID_MAPPING, all is ok, we've got a true MAC.
354	;;	354	;;
355	;; If MAC will equal to a zero, in the buffer. It means, that IP-address was not yet	355	;; If MAC will equal to a zero, in the buffer. It means, that IP-address was not yet
356	;; resolved, or that doesn't exist. I recommend you, to do at most 3-5 calls of this	356	;; resolved, or that doesn't exist. I recommend you, to do at most 3-5 calls of this
357	;; function with 1sec delay. sure, only if it not return a valid MAC after a first call.	357	;; function with 1sec delay. sure, only if it not return a valid MAC after a first call.
358	;;	358	;;
359	.ip_to_mac:	359	.ip_to_mac:
360		360
361	DEBUGF 1,"Trying to find MAC for %u.%u.%u.%u\n",[Index]:1,[Index+1]:1,[Index+2]:1,[Index+3]:1	361	DEBUGF 1,"Trying to find MAC for %u.%u.%u.%u\n",[Index]:1,[Index+1]:1,[Index+2]:1,[Index+3]:1
362		362
363	xor eax, eax	363	xor eax, eax
364	mov edi, dword[Extra]	364	mov edi, dword[Extra]
365	cld	365	cld
366	stosd	366	stosd
367	stosw	367	stosw
368		368
369		369
370	; first, check destination IP to see if it is on 'this' network.	370	; first, check destination IP to see if it is on 'this' network.
371	; The test is:	371	; The test is:
372	; if ( destIP & subnet_mask == stack_ip & subnet_mask )	372	; if ( destIP & subnet_mask == stack_ip & subnet_mask )
373	; destination is local	373	; destination is local
374	; else	374	; else
375	; destination is remote, so pass to gateway	375	; destination is remote, so pass to gateway
376		376
377		377
378	;;; TODO: get device number ! (in edx)	378	;;; TODO: get device number ! (in edx)
379	xor edx, edx	379	xor edx, edx
380		380
381	mov eax, [Index] ;eax=required IP	381	mov eax, [Index] ;eax=required IP
382	mov esi, eax	382	mov esi, eax
383	and esi, [SUBNET_LIST+edx]	383	and esi, [SUBNET_LIST+edx]
384	mov ecx, [IP_LIST+edx]	384	mov ecx, [IP_LIST+edx]
385	and ecx, [SUBNET_LIST+edx]	385	and ecx, [SUBNET_LIST+edx]
386	cmp esi, ecx	386	cmp esi, ecx
387	je @f ;if we and target IP are located in the same network	387	je @f ;if we and target IP are located in the same network
388	mov eax, [GATEWAY_LIST+edx]	388	mov eax, [GATEWAY_LIST+edx]
389	mov [Index], eax	389	mov [Index], eax
390	DEBUGF 1,"IP is not on subnet, using %u.%u.%u.%u instead\n",[Index]:1,[Index+1]:1,[Index+2]:1,[Index+3]:1	390	DEBUGF 1,"IP is not on subnet, using %u.%u.%u.%u instead\n",[Index]:1,[Index+1]:1,[Index+2]:1,[Index+3]:1
391	@@:	391	@@:
392		392
393	cmp dword[NumARP], 0	393	cmp dword[NumARP], 0
394	je .ip_to_mac_send_request ;if ARP-table not contain an entries, we have to request IP.	394	je .ip_to_mac_send_request ;if ARP-table not contain an entries, we have to request IP.
395	;EAX will be containing a zero, it's equal to ARP_NO_ENTRY	395	;EAX will be containing a zero, it's equal to ARP_NO_ENTRY
396		396
397	mov ecx, dword[NumARP]	397	mov ecx, dword[NumARP]
398	imul esi, ecx, ARP_ENTRY.size ;esi=current ARP-table size	398	imul esi, ecx, ARP_ENTRY.size ;esi=current ARP-table size
399		399
400	@@:	400	@@:
401	sub esi, ARP_ENTRY.size	401	sub esi, ARP_ENTRY.size
402	cmp [ebx + esi + ARP_ENTRY.IP], eax ; ebx=ARPTable base	402	cmp [ebx + esi + ARP_ENTRY.IP], eax ; ebx=ARPTable base
403	loopnz @b ; Return back if non match	403	loopnz @b ; Return back if non match
404	jnz .ip_to_mac_send_request ; and request IP->MAC if none found in the table	404	jnz .ip_to_mac_send_request ; and request IP->MAC if none found in the table
405		405
406	; Return the entry status in eax	406	; Return the entry status in eax
407	movzx eax, word[ebx + esi + ARP_ENTRY.Status]	407	movzx eax, word[ebx + esi + ARP_ENTRY.Status]
408		408
409	DEBUGF 1,"MAC found: %x-%x-%x-%x-%x-%x status:%x in slot:%u\n",\	409	DEBUGF 1,"MAC found: %x-%x-%x-%x-%x-%x status:%x in slot:%u\n",\
410	[ebx + esi + ARP_ENTRY.MAC]:2,[ebx + esi + ARP_ENTRY.MAC+1]:2,[ebx + esi + ARP_ENTRY.MAC+2]:2,[ebx + esi + ARP_ENTRY.MAC+3]:2,[ebx + esi + ARP_ENTRY.MAC+4]:2,[ebx + esi + ARP_ENTRY.MAC+5]:2, ax, esi	410	[ebx + esi + ARP_ENTRY.MAC]:2,[ebx + esi + ARP_ENTRY.MAC+1]:2,[ebx + esi + ARP_ENTRY.MAC+2]:2,[ebx + esi + ARP_ENTRY.MAC+3]:2,[ebx + esi + ARP_ENTRY.MAC+4]:2,[ebx + esi + ARP_ENTRY.MAC+5]:2, ax, esi
411		411
412	; esi holds index	412	; esi holds index
413	cld	413	cld
414	lea esi, [ebx + esi + ARP_ENTRY.MAC]	414	lea esi, [ebx + esi + ARP_ENTRY.MAC]
415	mov edi, [Extra] ;edi=ptr to buffer for write MAC	415	mov edi, [Extra] ;edi=ptr to buffer for write MAC
416	movsd	416	movsd
417	movsw	417	movsw
418	jmp .exit	418	jmp .exit
419		419
420	.ip_to_mac_send_request:	420	.ip_to_mac_send_request:
421	;;; TODO: get device number ! (in edx)	421	;;; TODO: get device number ! (in edx)
422	xor edx, edx	422	xor edx, edx
423	mov edx, [ETH_DRV_LIST + 4*edx]	423	mov edx, [ETH_DRV_LIST + 4*edx]
424	lea ecx, [edx + ETH_DEVICE.mac]	424	lea ecx, [edx + ETH_DEVICE.mac]
425		425
426	stdcall arp_request,[Index],[IP_LIST+edx],ecx ;TargetIP,SenderIP_ptr,SenderMAC_ptr	426	stdcall arp_request,[Index],[IP_LIST+edx],ecx ;TargetIP,SenderIP_ptr,SenderMAC_ptr
427	mov eax, ARP_NO_ENTRY	427	mov eax, ARP_NO_ENTRY
428	jmp .exit	428	jmp .exit
429		429
430	;;END IP_TO_MAC	430	;;END IP_TO_MAC
431		431
432	;;BEGIN GET_ENTRIES_NUMBER	432	;;BEGIN GET_ENTRIES_NUMBER
433	;;Description: returns an ARP-entries number in the ARPTable	433	;;Description: returns an ARP-entries number in the ARPTable
434	;;IN: Operation: ARP_TABLE_GET_ENTRIES_NUMBER	434	;;IN: Operation: ARP_TABLE_GET_ENTRIES_NUMBER
435	;; Index: must be zero	435	;; Index: must be zero
436	;; Extra: must be zero	436	;; Extra: must be zero
437	;;OUT:	437	;;OUT:
438	;; EAX=ARP-entries number in the ARPTable	438	;; EAX=ARP-entries number in the ARPTable
439	.get_entries_number:	439	.get_entries_number:
440	mov eax, dword[NumARP]	440	mov eax, dword[NumARP]
441	jmp .exit	441	jmp .exit
442	;;END GET_ENTRIES_NUMBER	442	;;END GET_ENTRIES_NUMBER
443		443
444	.exit:	444	.exit:
445	ret	445	ret
446	endp	446	endp
447		447
448		448
449	;***************************************************************************	449	;***************************************************************************
450	; Function	450	; Function
451	; arp_request [by Johnny_B]	451	; arp_request [by Johnny_B]
452	;	452	;
453	; Description	453	; Description
454	; Sends an ARP request on the ethernet	454	; Sends an ARP request on the ethernet
455	; IN:	455	; IN:
456	; TargetIP : requested IP address	456	; TargetIP : requested IP address
457	; SenderIP_ptr : POINTER to sender's IP address(our system's address)	457	; SenderIP_ptr : POINTER to sender's IP address(our system's address)
458	; SenderMAC_ptr : POINTER to sender's MAC address(our system's address)	458	; SenderMAC_ptr : POINTER to sender's MAC address(our system's address)
459	; OUT:	459	; OUT:
460	; EAX=0 (if all is ok), otherwise EAX is not defined	460	; EAX=0 (if all is ok), otherwise EAX is not defined
461	;	461	;
462	; EBX,ESI,EDI will be saved	462	; EBX,ESI,EDI will be saved
463	;	463	;
464	;***************************************************************************	464	;***************************************************************************
465	proc arp_request stdcall uses ebx esi edi,\	465	proc arp_request stdcall uses ebx esi edi,\
466	TargetIP:DWORD, SenderIP_ptr:DWORD, SenderMAC_ptr:DWORD	466	TargetIP:DWORD, SenderIP_ptr:DWORD, SenderMAC_ptr:DWORD
467		467
468	DEBUGF 1,"Create ARP request\n"	468	DEBUGF 1,"Create ARP request\n"
469		469
470		470
471	stdcall kernel_alloc, 60 ; minimum eth packet size	471	stdcall kernel_alloc, 60 ; minimum eth packet size
472	test eax, eax	472	test eax, eax
473	jz .exit	473	jz .exit
474		474
475	mov ebx, eax	475	mov ebx, eax
476		476
477	mov word [ebx + ETH_FRAME.Data + ARP_Packet.HardwareType], 0x0100 ;Ethernet	477	mov word [ebx + ETH_FRAME.Data + ARP_Packet.HardwareType], 0x0100 ;Ethernet
478	mov word [ebx + ETH_FRAME.Data + ARP_Packet.ProtocolType], 0x0008 ;IP	478	mov word [ebx + ETH_FRAME.Data + ARP_Packet.ProtocolType], 0x0008 ;IP
479	mov byte [ebx + ETH_FRAME.Data + ARP_Packet.HardwareSize], 0x06 ;MAC-addr length	479	mov byte [ebx + ETH_FRAME.Data + ARP_Packet.HardwareSize], 0x06 ;MAC-addr length
480	mov byte [ebx + ETH_FRAME.Data + ARP_Packet.ProtocolSize], 0x04 ;IP-addr length	480	mov byte [ebx + ETH_FRAME.Data + ARP_Packet.ProtocolSize], 0x04 ;IP-addr length
481	mov word [ebx + ETH_FRAME.Data + ARP_Packet.Opcode], 0x0100 ;Request	481	mov word [ebx + ETH_FRAME.Data + ARP_Packet.Opcode], 0x0100 ;Request
482		482
483	DEBUGF 1,"1"	483	DEBUGF 1,"1"
484		484
485	cld	485	cld
486	mov esi, [SenderMAC_ptr]	486	mov esi, [SenderMAC_ptr]
487	lea edi, [ebx + ETH_FRAME.Data + ARP_Packet.SenderMAC] ;Our MAC-addr	487	lea edi, [ebx + ETH_FRAME.Data + ARP_Packet.SenderMAC] ;Our MAC-addr
488	movsd	488	movsd
489	movsw	489	movsw
490		490
491	DEBUGF 1,"2"	491	DEBUGF 1,"2"
492		492
493	mov esi, [SenderIP_ptr]	493	mov esi, [SenderIP_ptr]
494	mov [ebx + ETH_FRAME.Data + ARP_Packet.SenderIP], esi ;Our IP-addr	494	mov [ebx + ETH_FRAME.Data + ARP_Packet.SenderIP], esi ;Our IP-addr
495	; movsd	495	; movsd
496		496
497	DEBUGF 1,"3"	497	DEBUGF 1,"3"
498		498
499	lea edi, [ebx + ETH_FRAME.Data + ARP_Packet.TargetMAC] ; Required MAC-addr	499	lea edi, [ebx + ETH_FRAME.Data + ARP_Packet.TargetMAC] ; Required MAC-addr
500	xor eax, eax	500	xor eax, eax

Subversion Repositories Kolibri OS

(root)/kernel/branches/net/network/ARP.inc – Rev 1171 → 1185