1 /* linux/net/inet/arp.c
3 * Version: $Id: arp.c,v 1.90 2000/10/04 09:20:56 anton Exp $
5 * Copyright (C) 1994 by Florian La Roche
7 * This module implements the Address Resolution Protocol ARP (RFC 826),
8 * which is used to convert IP addresses (or in the future maybe other
9 * high-level addresses) into a low-level hardware address (like an Ethernet
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
18 * Alan Cox : Removed the Ethernet assumptions in
20 * Alan Cox : Fixed some small errors in the ARP
22 * Alan Cox : Allow >4K in /proc
23 * Alan Cox : Make ARP add its own protocol entry
24 * Ross Martin : Rewrote arp_rcv() and arp_get_info()
25 * Stephen Henson : Add AX25 support to arp_get_info()
26 * Alan Cox : Drop data when a device is downed.
27 * Alan Cox : Use init_timer().
28 * Alan Cox : Double lock fixes.
29 * Martin Seine : Move the arphdr structure
30 * to if_arp.h for compatibility.
31 * with BSD based programs.
32 * Andrew Tridgell : Added ARP netmask code and
33 * re-arranged proxy handling.
34 * Alan Cox : Changed to use notifiers.
35 * Niibe Yutaka : Reply for this device or proxies only.
36 * Alan Cox : Don't proxy across hardware types!
37 * Jonathan Naylor : Added support for NET/ROM.
38 * Mike Shaver : RFC1122 checks.
39 * Jonathan Naylor : Only lookup the hardware address for
40 * the correct hardware type.
41 * Germano Caronni : Assorted subtle races.
42 * Craig Schlenter : Don't modify permanent entry
44 * Russ Nelson : Tidied up a few bits.
45 * Alexey Kuznetsov: Major changes to caching and behaviour,
46 * eg intelligent arp probing and
48 * of host down events.
49 * Alan Cox : Missing unlock in device events.
50 * Eckes : ARP ioctl control errors.
51 * Alexey Kuznetsov: Arp free fix.
52 * Manuel Rodriguez: Gratuitous ARP.
53 * Jonathan Layes : Added arpd support through kerneld
54 * message queue (960314)
55 * Mike Shaver : /proc/sys/net/ipv4/arp_* support
56 * Mike McLagan : Routing by source
57 * Stuart Cheshire : Metricom and grat arp fixes
58 * *** FOR 2.1 clean this up ***
59 * Lawrence V. Stefani: (08/12/96) Added FDDI support.
60 * Alan Cox : Took the AP1000 nasty FDDI hack and
61 * folded into the mainstream FDDI code.
62 * Ack spit, Linus how did you allow that
64 * Jes Sorensen : Make FDDI work again in 2.1.x and
65 * clean up the APFDDI & gen. FDDI bits.
66 * Alexey Kuznetsov: new arp state machine;
67 * now it is in net/core/neighbour.c.
71 2.3.2.1 (ARP Cache Validation):
72 MUST provide mechanism to flush stale cache entries (OK)
73 SHOULD be able to configure cache timeout (OK)
74 MUST throttle ARP retransmits (OK)
75 2.3.2.2 (ARP Packet Queue):
76 SHOULD save at least one packet from each "conversation" with an
77 unresolved IP address. (OK)
81 #include <linux/types.h>
82 #include <linux/string.h>
83 #include <linux/kernel.h>
84 #include <linux/sched.h>
85 #include <linux/config.h>
86 #include <linux/socket.h>
87 #include <linux/sockios.h>
88 #include <linux/errno.h>
91 #include <linux/inet.h>
92 #include <linux/netdevice.h>
93 #include <linux/etherdevice.h>
94 #include <linux/fddidevice.h>
95 #include <linux/if_arp.h>
96 #include <linux/trdevice.h>
97 #include <linux/skbuff.h>
98 #include <linux/proc_fs.h>
99 #include <linux/stat.h>
100 #include <linux/init.h>
102 #include <linux/sysctl.h>
106 #include <net/icmp.h>
107 #include <net/route.h>
108 #include <net/protocol.h>
110 #include <net/sock.h>
112 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
113 #include <net/ax25.h>
114 #if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
115 #include <net/netrom.h>
118 #ifdef CONFIG_ATM_CLIP
119 #include <net/atmclip.h>
122 #include <asm/system.h>
123 #include <asm/uaccess.h>
128 * Interface to generic neighbour cache.
130 static u32
arp_hash(const void *pkey
, const struct net_device
*dev
);
131 static int arp_constructor(struct neighbour
*neigh
);
132 static void arp_solicit(struct neighbour
*neigh
, struct sk_buff
*skb
);
133 static void arp_error_report(struct neighbour
*neigh
, struct sk_buff
*skb
);
134 static void parp_redo(struct sk_buff
*skb
);
136 static struct neigh_ops arp_generic_ops
=
142 neigh_resolve_output
,
143 neigh_connected_output
,
148 static struct neigh_ops arp_hh_ops
=
154 neigh_resolve_output
,
155 neigh_resolve_output
,
160 static struct neigh_ops arp_direct_ops
=
172 struct neigh_ops arp_broken_ops
=
184 struct neigh_table arp_tbl
=
188 sizeof(struct neighbour
) + 4,
196 { NULL
, NULL
, &arp_tbl
, 0, NULL
, NULL
,
197 30*HZ
, 1*HZ
, 60*HZ
, 30*HZ
, 5*HZ
, 3, 3, 0, 3, 1*HZ
, (8*HZ
)/10, 64, 1*HZ
},
198 30*HZ
, 128, 512, 1024,
201 int arp_mc_map(u32 addr
, u8
*haddr
, struct net_device
*dev
, int dir
)
207 ip_eth_mc_map(addr
, haddr
) ;
209 case ARPHRD_IEEE802_TR
:
210 ip_tr_mc_map(addr
, haddr
) ;
214 memcpy(haddr
, dev
->broadcast
, dev
->addr_len
);
222 static u32
arp_hash(const void *pkey
, const struct net_device
*dev
)
226 hash_val
= *(u32
*)pkey
;
227 hash_val
^= (hash_val
>>16);
228 hash_val
^= hash_val
>>8;
229 hash_val
^= hash_val
>>3;
230 hash_val
= (hash_val
^dev
->ifindex
)&NEIGH_HASHMASK
;
235 static int arp_constructor(struct neighbour
*neigh
)
237 u32 addr
= *(u32
*)neigh
->primary_key
;
238 struct net_device
*dev
= neigh
->dev
;
239 struct in_device
*in_dev
= in_dev_get(dev
);
244 neigh
->type
= inet_addr_type(addr
);
245 if (in_dev
->arp_parms
)
246 neigh
->parms
= in_dev
->arp_parms
;
250 if (dev
->hard_header
== NULL
) {
251 neigh
->nud_state
= NUD_NOARP
;
252 neigh
->ops
= &arp_direct_ops
;
253 neigh
->output
= neigh
->ops
->queue_xmit
;
255 /* Good devices (checked by reading texts, but only Ethernet is
258 ARPHRD_ETHER: (ethernet, apfddi)
261 ARPHRD_METRICOM: (strip)
265 ARPHRD_IPDDP will also work, if author repairs it.
266 I did not it, because this driver does not work even
271 /* So... these "amateur" devices are hopeless.
272 The only thing, that I can say now:
273 It is very sad that we need to keep ugly obsolete
274 code to make them happy.
276 They should be moved to more reasonable state, now
277 they use rebuild_header INSTEAD OF hard_start_xmit!!!
278 Besides that, they are sort of out of date
279 (a lot of redundant clones/copies, useless in 2.1),
280 I wonder why people believe that they work.
286 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
288 #if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
291 neigh
->ops
= &arp_broken_ops
;
292 neigh
->output
= neigh
->ops
->output
;
297 if (neigh
->type
== RTN_MULTICAST
) {
298 neigh
->nud_state
= NUD_NOARP
;
299 arp_mc_map(addr
, neigh
->ha
, dev
, 1);
300 } else if (dev
->flags
&(IFF_NOARP
|IFF_LOOPBACK
)) {
301 neigh
->nud_state
= NUD_NOARP
;
302 memcpy(neigh
->ha
, dev
->dev_addr
, dev
->addr_len
);
303 } else if (neigh
->type
== RTN_BROADCAST
|| dev
->flags
&IFF_POINTOPOINT
) {
304 neigh
->nud_state
= NUD_NOARP
;
305 memcpy(neigh
->ha
, dev
->broadcast
, dev
->addr_len
);
307 if (dev
->hard_header_cache
)
308 neigh
->ops
= &arp_hh_ops
;
310 neigh
->ops
= &arp_generic_ops
;
311 if (neigh
->nud_state
&NUD_VALID
)
312 neigh
->output
= neigh
->ops
->connected_output
;
314 neigh
->output
= neigh
->ops
->output
;
319 static void arp_error_report(struct neighbour
*neigh
, struct sk_buff
*skb
)
321 dst_link_failure(skb
);
325 static void arp_solicit(struct neighbour
*neigh
, struct sk_buff
*skb
)
329 struct net_device
*dev
= neigh
->dev
;
330 u32 target
= *(u32
*)neigh
->primary_key
;
331 int probes
= atomic_read(&neigh
->probes
);
333 if (skb
&& inet_addr_type(skb
->nh
.iph
->saddr
) == RTN_LOCAL
)
334 saddr
= skb
->nh
.iph
->saddr
;
336 saddr
= inet_select_addr(dev
, target
, RT_SCOPE_LINK
);
338 if ((probes
-= neigh
->parms
->ucast_probes
) < 0) {
339 if (!(neigh
->nud_state
&NUD_VALID
))
340 printk(KERN_DEBUG
"trying to ucast probe in NUD_INVALID\n");
342 read_lock_bh(&neigh
->lock
);
343 } else if ((probes
-= neigh
->parms
->app_probes
) < 0) {
350 arp_send(ARPOP_REQUEST
, ETH_P_ARP
, target
, dev
, saddr
,
351 dst_ha
, dev
->dev_addr
, NULL
);
353 read_unlock_bh(&neigh
->lock
);
356 /* OBSOLETE FUNCTIONS */
359 * Find an arp mapping in the cache. If not found, post a request.
361 * It is very UGLY routine: it DOES NOT use skb->dst->neighbour,
362 * even if it exists. It is supposed that skb->dev was mangled
363 * by a virtual device (eql, shaper). Nobody but broken devices
364 * is allowed to use this function, it is scheduled to be removed. --ANK
367 static int arp_set_predefined(int addr_hint
, unsigned char * haddr
, u32 paddr
, struct net_device
* dev
)
371 printk(KERN_DEBUG
"ARP: arp called for own IP address\n");
372 memcpy(haddr
, dev
->dev_addr
, dev
->addr_len
);
375 arp_mc_map(paddr
, haddr
, dev
, 1);
378 memcpy(haddr
, dev
->broadcast
, dev
->addr_len
);
385 int arp_find(unsigned char *haddr
, struct sk_buff
*skb
)
387 struct net_device
*dev
= skb
->dev
;
392 printk(KERN_DEBUG
"arp_find is called with dst==NULL\n");
397 paddr
= ((struct rtable
*)skb
->dst
)->rt_gateway
;
399 if (arp_set_predefined(inet_addr_type(paddr
), haddr
, paddr
, dev
))
402 n
= __neigh_lookup(&arp_tbl
, &paddr
, dev
, 1);
406 if (n
->nud_state
&NUD_VALID
|| neigh_event_send(n
, skb
) == 0) {
407 read_lock_bh(&n
->lock
);
408 memcpy(haddr
, n
->ha
, dev
->addr_len
);
409 read_unlock_bh(&n
->lock
);
419 /* END OF OBSOLETE FUNCTIONS */
421 int arp_bind_neighbour(struct dst_entry
*dst
)
423 struct net_device
*dev
= dst
->dev
;
424 struct neighbour
*n
= dst
->neighbour
;
429 u32 nexthop
= ((struct rtable
*)dst
)->rt_gateway
;
430 if (dev
->flags
&(IFF_LOOPBACK
|IFF_POINTOPOINT
))
432 n
= __neigh_lookup_errno(
433 #ifdef CONFIG_ATM_CLIP
434 dev
->type
== ARPHRD_ATM
? &clip_tbl
:
436 &arp_tbl
, &nexthop
, dev
);
445 * Interface to link layer: send routine and receive handler.
449 * Create and send an arp packet. If (dest_hw == NULL), we create a broadcast
453 void arp_send(int type
, int ptype
, u32 dest_ip
,
454 struct net_device
*dev
, u32 src_ip
,
455 unsigned char *dest_hw
, unsigned char *src_hw
,
456 unsigned char *target_hw
)
460 unsigned char *arp_ptr
;
463 * No arp on this interface.
466 if (dev
->flags
&IFF_NOARP
)
473 skb
= alloc_skb(sizeof(struct arphdr
)+ 2*(dev
->addr_len
+4)
474 + dev
->hard_header_len
+ 15, GFP_ATOMIC
);
478 skb_reserve(skb
, (dev
->hard_header_len
+15)&~15);
479 skb
->nh
.raw
= skb
->data
;
480 arp
= (struct arphdr
*) skb_put(skb
,sizeof(struct arphdr
) + 2*(dev
->addr_len
+4));
482 skb
->protocol
= __constant_htons (ETH_P_ARP
);
484 src_hw
= dev
->dev_addr
;
486 dest_hw
= dev
->broadcast
;
489 * Fill the device header for the ARP frame
491 if (dev
->hard_header
&&
492 dev
->hard_header(skb
,dev
,ptype
,dest_hw
,src_hw
,skb
->len
) < 0)
496 * Fill out the arp protocol part.
498 * The arp hardware type should match the device type, except for FDDI,
499 * which (according to RFC 1390) should always equal 1 (Ethernet).
502 * Exceptions everywhere. AX.25 uses the AX.25 PID value not the
503 * DIX code for the protocol. Make these device structure fields.
507 arp
->ar_hrd
= htons(dev
->type
);
508 arp
->ar_pro
= __constant_htons(ETH_P_IP
);
511 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
513 arp
->ar_hrd
= __constant_htons(ARPHRD_AX25
);
514 arp
->ar_pro
= __constant_htons(AX25_P_IP
);
517 #if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
519 arp
->ar_hrd
= __constant_htons(ARPHRD_NETROM
);
520 arp
->ar_pro
= __constant_htons(AX25_P_IP
);
527 arp
->ar_hrd
= __constant_htons(ARPHRD_ETHER
);
528 arp
->ar_pro
= __constant_htons(ETH_P_IP
);
532 case ARPHRD_IEEE802_TR
:
533 arp
->ar_hrd
= __constant_htons(ARPHRD_IEEE802
);
534 arp
->ar_pro
= __constant_htons(ETH_P_IP
);
539 arp
->ar_hln
= dev
->addr_len
;
541 arp
->ar_op
= htons(type
);
543 arp_ptr
=(unsigned char *)(arp
+1);
545 memcpy(arp_ptr
, src_hw
, dev
->addr_len
);
546 arp_ptr
+=dev
->addr_len
;
547 memcpy(arp_ptr
, &src_ip
,4);
549 if (target_hw
!= NULL
)
550 memcpy(arp_ptr
, target_hw
, dev
->addr_len
);
552 memset(arp_ptr
, 0, dev
->addr_len
);
553 arp_ptr
+=dev
->addr_len
;
554 memcpy(arp_ptr
, &dest_ip
, 4);
564 static void parp_redo(struct sk_buff
*skb
)
566 arp_rcv(skb
, skb
->dev
, NULL
);
570 * Receive an arp request by the device layer.
573 int arp_rcv(struct sk_buff
*skb
, struct net_device
*dev
, struct packet_type
*pt
)
575 struct arphdr
*arp
= skb
->nh
.arph
;
576 unsigned char *arp_ptr
= (unsigned char *)(arp
+1);
578 unsigned char *sha
, *tha
;
580 u16 dev_type
= dev
->type
;
582 struct in_device
*in_dev
= in_dev_get(dev
);
586 * The hardware length of the packet should match the hardware length
587 * of the device. Similarly, the hardware types should match. The
588 * device should be ARP-able. Also, if pln is not 4, then the lookup
589 * is not from an IP number. We can't currently handle this, so toss
592 if (in_dev
== NULL
||
593 arp
->ar_hln
!= dev
->addr_len
||
594 dev
->flags
& IFF_NOARP
||
595 skb
->pkt_type
== PACKET_OTHERHOST
||
596 skb
->pkt_type
== PACKET_LOOPBACK
||
600 if ((skb
= skb_share_check(skb
, GFP_ATOMIC
)) == NULL
)
605 if (arp
->ar_pro
!= __constant_htons(ETH_P_IP
))
607 if (htons(dev_type
) != arp
->ar_hrd
)
610 #ifdef CONFIG_NET_ETHERNET
613 * ETHERNET devices will accept ARP hardware types of either
614 * 1 (Ethernet) or 6 (IEEE 802.2).
616 if (arp
->ar_hrd
!= __constant_htons(ARPHRD_ETHER
) &&
617 arp
->ar_hrd
!= __constant_htons(ARPHRD_IEEE802
))
619 if (arp
->ar_pro
!= __constant_htons(ETH_P_IP
))
624 case ARPHRD_IEEE802_TR
:
626 * Token ring devices will accept ARP hardware types of either
627 * 1 (Ethernet) or 6 (IEEE 802.2).
629 if (arp
->ar_hrd
!= __constant_htons(ARPHRD_ETHER
) &&
630 arp
->ar_hrd
!= __constant_htons(ARPHRD_IEEE802
))
632 if (arp
->ar_pro
!= __constant_htons(ETH_P_IP
))
639 * According to RFC 1390, FDDI devices should accept ARP hardware types
640 * of 1 (Ethernet). However, to be more robust, we'll accept hardware
641 * types of either 1 (Ethernet) or 6 (IEEE 802.2).
643 if (arp
->ar_hrd
!= __constant_htons(ARPHRD_ETHER
) &&
644 arp
->ar_hrd
!= __constant_htons(ARPHRD_IEEE802
))
646 if (arp
->ar_pro
!= __constant_htons(ETH_P_IP
))
650 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
652 if (arp
->ar_pro
!= __constant_htons(AX25_P_IP
))
654 if (arp
->ar_hrd
!= __constant_htons(ARPHRD_AX25
))
657 #if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
659 if (arp
->ar_pro
!= __constant_htons(AX25_P_IP
))
661 if (arp
->ar_hrd
!= __constant_htons(ARPHRD_NETROM
))
668 /* Understand only these message types */
670 if (arp
->ar_op
!= __constant_htons(ARPOP_REPLY
) &&
671 arp
->ar_op
!= __constant_htons(ARPOP_REQUEST
))
678 arp_ptr
+= dev
->addr_len
;
679 memcpy(&sip
, arp_ptr
, 4);
682 arp_ptr
+= dev
->addr_len
;
683 memcpy(&tip
, arp_ptr
, 4);
685 * Check for bad requests for 127.x.x.x and requests for multicast
686 * addresses. If this is one such, delete it.
688 if (LOOPBACK(tip
) || MULTICAST(tip
))
692 * Process entry. The idea here is we want to send a reply if it is a
693 * request for us or if it is a request for someone else that we hold
694 * a proxy for. We want to add an entry to our cache if it is a reply
695 * to us or if it is a request for our address.
696 * (The assumption for this last is that if someone is requesting our
697 * address, they are probably intending to talk to us, so it saves time
698 * if we cache their address. Their address is also probably not in
699 * our cache, since ours is not in their cache.)
701 * Putting this another way, we only care about replies if they are to
702 * us, in which case we add them to the cache. For requests, we care
703 * about those for us and those for our proxies. We reply to both,
704 * and in the case of requests for us we add the requester to the arp
708 /* Special case: IPv4 duplicate address detection packet (RFC2131) */
710 if (arp
->ar_op
== __constant_htons(ARPOP_REQUEST
) &&
711 inet_addr_type(tip
) == RTN_LOCAL
)
712 arp_send(ARPOP_REPLY
,ETH_P_ARP
,tip
,dev
,tip
,sha
,dev
->dev_addr
,dev
->dev_addr
);
716 if (arp
->ar_op
== __constant_htons(ARPOP_REQUEST
) &&
717 ip_route_input(skb
, tip
, sip
, 0, dev
) == 0) {
719 rt
= (struct rtable
*)skb
->dst
;
720 addr_type
= rt
->rt_type
;
722 if (addr_type
== RTN_LOCAL
) {
723 n
= neigh_event_ns(&arp_tbl
, sha
, &sip
, dev
);
725 arp_send(ARPOP_REPLY
,ETH_P_ARP
,sip
,dev
,tip
,sha
,dev
->dev_addr
,sha
);
729 } else if (IN_DEV_FORWARD(in_dev
)) {
730 if ((rt
->rt_flags
&RTCF_DNAT
) ||
731 (addr_type
== RTN_UNICAST
&& rt
->u
.dst
.dev
!= dev
&&
732 (IN_DEV_PROXY_ARP(in_dev
) || pneigh_lookup(&arp_tbl
, &tip
, dev
, 0)))) {
733 n
= neigh_event_ns(&arp_tbl
, sha
, &sip
, dev
);
737 if (skb
->stamp
.tv_sec
== 0 ||
738 skb
->pkt_type
== PACKET_HOST
||
739 in_dev
->arp_parms
->proxy_delay
== 0) {
740 arp_send(ARPOP_REPLY
,ETH_P_ARP
,sip
,dev
,tip
,sha
,dev
->dev_addr
,sha
);
742 pneigh_enqueue(&arp_tbl
, in_dev
->arp_parms
, skb
);
751 /* Update our ARP tables */
753 n
= __neigh_lookup(&arp_tbl
, &sip
, dev
, 0);
755 #ifdef CONFIG_IP_ACCEPT_UNSOLICITED_ARP
756 /* Unsolicited ARP is not accepted by default.
757 It is possible, that this option should be enabled for some
758 devices (strip is candidate)
761 arp
->ar_op
== __constant_htons(ARPOP_REPLY
) &&
762 inet_addr_type(sip
) == RTN_UNICAST
)
763 n
= __neigh_lookup(&arp_tbl
, &sip
, dev
, -1);
767 int state
= NUD_REACHABLE
;
770 /* If several different ARP replies follows back-to-back,
771 use the FIRST one. It is possible, if several proxy
772 agents are active. Taking the first reply prevents
773 arp trashing and chooses the fastest router.
775 if (jiffies
- n
->updated
>= n
->parms
->locktime
)
778 /* Broadcast replies and request packets
779 do not assert neighbour reachability.
781 if (arp
->ar_op
!= __constant_htons(ARPOP_REPLY
) ||
782 skb
->pkt_type
!= PACKET_HOST
)
784 neigh_update(n
, sha
, state
, override
, 1);
799 * User level interface (ioctl, /proc)
803 * Set (create) an ARP cache entry.
806 int arp_req_set(struct arpreq
*r
, struct net_device
* dev
)
808 u32 ip
= ((struct sockaddr_in
*) &r
->arp_pa
)->sin_addr
.s_addr
;
809 struct neighbour
*neigh
;
812 if (r
->arp_flags
&ATF_PUBL
) {
813 u32 mask
= ((struct sockaddr_in
*) &r
->arp_netmask
)->sin_addr
.s_addr
;
814 if (mask
&& mask
!= 0xFFFFFFFF)
816 if (!dev
&& (r
->arp_flags
& ATF_COM
)) {
817 dev
= dev_getbyhwaddr(r
->arp_ha
.sa_family
, r
->arp_ha
.sa_data
);
822 if (pneigh_lookup(&arp_tbl
, &ip
, dev
, 1) == NULL
)
827 ipv4_devconf
.proxy_arp
= 1;
830 if (__in_dev_get(dev
)) {
831 __in_dev_get(dev
)->cnf
.proxy_arp
= 1;
837 if (r
->arp_flags
& ATF_PERM
)
838 r
->arp_flags
|= ATF_COM
;
841 if ((err
= ip_route_output(&rt
, ip
, 0, RTO_ONLINK
, 0)) != 0)
848 if (r
->arp_ha
.sa_family
!= dev
->type
)
851 neigh
= __neigh_lookup_errno(&arp_tbl
, &ip
, dev
);
852 err
= PTR_ERR(neigh
);
853 if (!IS_ERR(neigh
)) {
854 unsigned state
= NUD_STALE
;
855 if (r
->arp_flags
& ATF_PERM
)
856 state
= NUD_PERMANENT
;
857 err
= neigh_update(neigh
, (r
->arp_flags
&ATF_COM
) ?
858 r
->arp_ha
.sa_data
: NULL
, state
, 1, 0);
859 neigh_release(neigh
);
864 static unsigned arp_state_to_flags(struct neighbour
*neigh
)
867 if (neigh
->nud_state
&NUD_PERMANENT
)
868 flags
= ATF_PERM
|ATF_COM
;
869 else if (neigh
->nud_state
&NUD_VALID
)
875 * Get an ARP cache entry.
878 static int arp_req_get(struct arpreq
*r
, struct net_device
*dev
)
880 u32 ip
= ((struct sockaddr_in
*) &r
->arp_pa
)->sin_addr
.s_addr
;
881 struct neighbour
*neigh
;
884 neigh
= neigh_lookup(&arp_tbl
, &ip
, dev
);
886 read_lock_bh(&neigh
->lock
);
887 memcpy(r
->arp_ha
.sa_data
, neigh
->ha
, dev
->addr_len
);
888 r
->arp_flags
= arp_state_to_flags(neigh
);
889 read_unlock_bh(&neigh
->lock
);
890 r
->arp_ha
.sa_family
= dev
->type
;
891 strncpy(r
->arp_dev
, dev
->name
, sizeof(r
->arp_dev
));
892 neigh_release(neigh
);
898 int arp_req_delete(struct arpreq
*r
, struct net_device
* dev
)
901 u32 ip
= ((struct sockaddr_in
*)&r
->arp_pa
)->sin_addr
.s_addr
;
902 struct neighbour
*neigh
;
904 if (r
->arp_flags
& ATF_PUBL
) {
905 u32 mask
= ((struct sockaddr_in
*) &r
->arp_netmask
)->sin_addr
.s_addr
;
906 if (mask
== 0xFFFFFFFF)
907 return pneigh_delete(&arp_tbl
, &ip
, dev
);
910 ipv4_devconf
.proxy_arp
= 0;
913 if (__in_dev_get(dev
)) {
914 __in_dev_get(dev
)->cnf
.proxy_arp
= 0;
924 if ((err
= ip_route_output(&rt
, ip
, 0, RTO_ONLINK
, 0)) != 0)
932 neigh
= neigh_lookup(&arp_tbl
, &ip
, dev
);
934 if (neigh
->nud_state
&~NUD_NOARP
)
935 err
= neigh_update(neigh
, NULL
, NUD_FAILED
, 1, 0);
936 neigh_release(neigh
);
942 * Handle an ARP layer I/O control request.
945 int arp_ioctl(unsigned int cmd
, void *arg
)
949 struct net_device
* dev
= NULL
;
954 if (!capable(CAP_NET_ADMIN
))
957 err
= copy_from_user(&r
, arg
, sizeof(struct arpreq
));
965 if (r
.arp_pa
.sa_family
!= AF_INET
)
966 return -EPFNOSUPPORT
;
968 if (!(r
.arp_flags
& ATF_PUBL
) &&
969 (r
.arp_flags
& (ATF_NETMASK
|ATF_DONTPUB
)))
971 if (!(r
.arp_flags
& ATF_NETMASK
))
972 ((struct sockaddr_in
*)&r
.arp_netmask
)->sin_addr
.s_addr
=__constant_htonl(0xFFFFFFFFUL
);
977 if ((dev
= __dev_get_by_name(r
.arp_dev
)) == NULL
)
980 /* Mmmm... It is wrong... ARPHRD_NETROM==0 */
981 if (!r
.arp_ha
.sa_family
)
982 r
.arp_ha
.sa_family
= dev
->type
;
984 if ((r
.arp_flags
& ATF_COM
) && r
.arp_ha
.sa_family
!= dev
->type
)
986 } else if (cmd
== SIOCGARP
) {
993 err
= arp_req_delete(&r
, dev
);
996 err
= arp_req_set(&r
, dev
);
999 err
= arp_req_get(&r
, dev
);
1000 if (!err
&& copy_to_user(arg
, &r
, sizeof(r
)))
1010 * Write the contents of the ARP cache to a PROCfs file.
1012 #ifndef CONFIG_PROC_FS
1013 static int arp_get_info(char *buffer
, char **start
, off_t offset
, int length
) { return 0; }
1015 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1016 static char *ax2asc2(ax25_address
*a
, char *buf
);
1018 #define HBUFFERLEN 30
1020 static int arp_get_info(char *buffer
, char **start
, off_t offset
, int length
)
1025 char hbuffer
[HBUFFERLEN
];
1027 const char hexbuf
[] = "0123456789ABCDEF";
1029 size
= sprintf(buffer
,"IP address HW type Flags HW address Mask Device\n");
1034 for(i
=0; i
<=NEIGH_HASHMASK
; i
++) {
1035 struct neighbour
*n
;
1036 read_lock_bh(&arp_tbl
.lock
);
1037 for (n
=arp_tbl
.hash_buckets
[i
]; n
; n
=n
->next
) {
1038 struct net_device
*dev
= n
->dev
;
1039 int hatype
= dev
->type
;
1041 /* Do not confuse users "arp -a" with magic entries */
1042 if (!(n
->nud_state
&~NUD_NOARP
))
1045 read_lock(&n
->lock
);
1048 * Convert hardware address to XX:XX:XX:XX ... form.
1050 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1051 if (hatype
== ARPHRD_AX25
|| hatype
== ARPHRD_NETROM
)
1052 ax2asc2((ax25_address
*)n
->ha
, hbuffer
);
1055 for (k
=0,j
=0;k
<HBUFFERLEN
-3 && j
<dev
->addr_len
;j
++) {
1056 hbuffer
[k
++]=hexbuf
[(n
->ha
[j
]>>4)&15 ];
1057 hbuffer
[k
++]=hexbuf
[n
->ha
[j
]&15 ];
1062 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1068 sprintf(tbuf
, "%u.%u.%u.%u", NIPQUAD(*(u32
*)n
->primary_key
));
1069 size
= sprintf(buffer
+len
, "%-16s 0x%-10x0x%-10x%s"
1073 arp_state_to_flags(n
),
1078 read_unlock(&n
->lock
);
1085 if (pos
>= offset
+length
) {
1086 read_unlock_bh(&arp_tbl
.lock
);
1090 read_unlock_bh(&arp_tbl
.lock
);
1093 for (i
=0; i
<=PNEIGH_HASHMASK
; i
++) {
1094 struct pneigh_entry
*n
;
1095 for (n
=arp_tbl
.phash_buckets
[i
]; n
; n
=n
->next
) {
1096 struct net_device
*dev
= n
->dev
;
1097 int hatype
= dev
? dev
->type
: 0;
1101 sprintf(tbuf
, "%u.%u.%u.%u", NIPQUAD(*(u32
*)n
->key
));
1102 size
= sprintf(buffer
+len
, "%-16s 0x%-10x0x%-10x%s"
1107 "00:00:00:00:00:00",
1108 dev
? dev
->name
: "*");
1116 if (pos
>= offset
+length
)
1123 *start
= buffer
+len
-(pos
-offset
); /* Start of wanted data */
1124 len
= pos
-offset
; /* Start slop */
1126 len
= length
; /* Ending slop */
1133 /* Note, that it is not on notifier chain.
1134 It is necessary, that this routine was called after route cache will be
1137 void arp_ifdown(struct net_device
*dev
)
1139 neigh_ifdown(&arp_tbl
, dev
);
1144 * Called once on startup.
1147 static struct packet_type arp_packet_type
=
1149 __constant_htons(ETH_P_ARP
),
1150 NULL
, /* All devices */
1156 void __init
arp_init (void)
1158 neigh_table_init(&arp_tbl
);
1160 dev_add_pack(&arp_packet_type
);
1162 proc_net_create ("arp", 0, arp_get_info
);
1164 #ifdef CONFIG_SYSCTL
1165 neigh_sysctl_register(NULL
, &arp_tbl
.parms
, NET_IPV4
, NET_IPV4_NEIGH
, "ipv4");
1170 #ifdef CONFIG_PROC_FS
1171 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1174 * ax25 -> ASCII conversion
1176 char *ax2asc2(ax25_address
*a
, char *buf
)
1181 for (n
= 0, s
= buf
; n
< 6; n
++) {
1182 c
= (a
->ax25_call
[n
] >> 1) & 0x7F;
1184 if (c
!= ' ') *s
++ = c
;
1189 if ((n
= ((a
->ax25_call
[6] >> 1) & 0x0F)) > 9) {
1197 if (*buf
== '\0' || *buf
== '-')