1 /* linux/net/ipv4/arp.c
3 * Copyright (C) 1994 by Florian La Roche
5 * This module implements the Address Resolution Protocol ARP (RFC 826),
6 * which is used to convert IP addresses (or in the future maybe other
7 * high-level addresses) into a low-level hardware address (like an Ethernet
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version
13 * 2 of the License, or (at your option) any later version.
16 * Alan Cox : Removed the Ethernet assumptions in
18 * Alan Cox : Fixed some small errors in the ARP
20 * Alan Cox : Allow >4K in /proc
21 * Alan Cox : Make ARP add its own protocol entry
22 * Ross Martin : Rewrote arp_rcv() and arp_get_info()
23 * Stephen Henson : Add AX25 support to arp_get_info()
24 * Alan Cox : Drop data when a device is downed.
25 * Alan Cox : Use init_timer().
26 * Alan Cox : Double lock fixes.
27 * Martin Seine : Move the arphdr structure
28 * to if_arp.h for compatibility.
29 * with BSD based programs.
30 * Andrew Tridgell : Added ARP netmask code and
31 * re-arranged proxy handling.
32 * Alan Cox : Changed to use notifiers.
33 * Niibe Yutaka : Reply for this device or proxies only.
34 * Alan Cox : Don't proxy across hardware types!
35 * Jonathan Naylor : Added support for NET/ROM.
36 * Mike Shaver : RFC1122 checks.
37 * Jonathan Naylor : Only lookup the hardware address for
38 * the correct hardware type.
39 * Germano Caronni : Assorted subtle races.
40 * Craig Schlenter : Don't modify permanent entry
42 * Russ Nelson : Tidied up a few bits.
43 * Alexey Kuznetsov: Major changes to caching and behaviour,
44 * eg intelligent arp probing and
46 * of host down events.
47 * Alan Cox : Missing unlock in device events.
48 * Eckes : ARP ioctl control errors.
49 * Alexey Kuznetsov: Arp free fix.
50 * Manuel Rodriguez: Gratuitous ARP.
51 * Jonathan Layes : Added arpd support through kerneld
52 * message queue (960314)
53 * Mike Shaver : /proc/sys/net/ipv4/arp_* support
54 * Mike McLagan : Routing by source
55 * Stuart Cheshire : Metricom and grat arp fixes
56 * *** FOR 2.1 clean this up ***
57 * Lawrence V. Stefani: (08/12/96) Added FDDI support.
58 * Alan Cox : Took the AP1000 nasty FDDI hack and
59 * folded into the mainstream FDDI code.
60 * Ack spit, Linus how did you allow that
62 * Jes Sorensen : Make FDDI work again in 2.1.x and
63 * clean up the APFDDI & gen. FDDI bits.
64 * Alexey Kuznetsov: new arp state machine;
65 * now it is in net/core/neighbour.c.
66 * Krzysztof Halasa: Added Frame Relay ARP support.
67 * Arnaldo C. Melo : convert /proc/net/arp to seq_file
68 * Shmulik Hen: Split arp_send to arp_create and
69 * arp_xmit so intermediate drivers like
70 * bonding can change the skb before
71 * sending (e.g. insert 8021q tag).
72 * Harald Welte : convert to make use of jenkins hash
73 * Jesper D. Brouer: Proxy ARP PVLAN RFC 3069 support.
76 #include <linux/module.h>
77 #include <linux/types.h>
78 #include <linux/string.h>
79 #include <linux/kernel.h>
80 #include <linux/capability.h>
81 #include <linux/socket.h>
82 #include <linux/sockios.h>
83 #include <linux/errno.h>
86 #include <linux/inet.h>
87 #include <linux/inetdevice.h>
88 #include <linux/netdevice.h>
89 #include <linux/etherdevice.h>
90 #include <linux/fddidevice.h>
91 #include <linux/if_arp.h>
92 #include <linux/trdevice.h>
93 #include <linux/skbuff.h>
94 #include <linux/proc_fs.h>
95 #include <linux/seq_file.h>
96 #include <linux/stat.h>
97 #include <linux/init.h>
98 #include <linux/net.h>
99 #include <linux/rcupdate.h>
100 #include <linux/jhash.h>
102 #include <linux/sysctl.h>
105 #include <net/net_namespace.h>
107 #include <net/icmp.h>
108 #include <net/route.h>
109 #include <net/protocol.h>
111 #include <net/sock.h>
113 #include <net/ax25.h>
114 #include <net/netrom.h>
115 #if defined(CONFIG_ATM_CLIP) || defined(CONFIG_ATM_CLIP_MODULE)
116 #include <net/atmclip.h>
117 struct neigh_table *clip_tbl_hook;
120 #include <asm/system.h>
121 #include <asm/uaccess.h>
123 #include <linux/netfilter_arp.h>
126 * Interface to generic neighbour cache.
128 static u32 arp_hash(const void *pkey, const struct net_device *dev);
129 static int arp_constructor(struct neighbour *neigh);
130 static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb);
131 static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb);
132 static void parp_redo(struct sk_buff *skb);
134 static const struct neigh_ops arp_generic_ops = {
136 .solicit = arp_solicit,
137 .error_report = arp_error_report,
138 .output = neigh_resolve_output,
139 .connected_output = neigh_connected_output,
140 .hh_output = dev_queue_xmit,
141 .queue_xmit = dev_queue_xmit,
144 static const struct neigh_ops arp_hh_ops = {
146 .solicit = arp_solicit,
147 .error_report = arp_error_report,
148 .output = neigh_resolve_output,
149 .connected_output = neigh_resolve_output,
150 .hh_output = dev_queue_xmit,
151 .queue_xmit = dev_queue_xmit,
154 static const struct neigh_ops arp_direct_ops = {
156 .output = dev_queue_xmit,
157 .connected_output = dev_queue_xmit,
158 .hh_output = dev_queue_xmit,
159 .queue_xmit = dev_queue_xmit,
162 const struct neigh_ops arp_broken_ops = {
164 .solicit = arp_solicit,
165 .error_report = arp_error_report,
166 .output = neigh_compat_output,
167 .connected_output = neigh_compat_output,
168 .hh_output = dev_queue_xmit,
169 .queue_xmit = dev_queue_xmit,
172 struct neigh_table arp_tbl = {
174 .entry_size = sizeof(struct neighbour) + 4,
177 .constructor = arp_constructor,
178 .proxy_redo = parp_redo,
182 .base_reachable_time = 30 * HZ,
183 .retrans_time = 1 * HZ,
184 .gc_staletime = 60 * HZ,
185 .reachable_time = 30 * HZ,
186 .delay_probe_time = 5 * HZ,
190 .anycast_delay = 1 * HZ,
191 .proxy_delay = (8 * HZ) / 10,
195 .gc_interval = 30 * HZ,
201 int arp_mc_map(__be32 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);
212 case ARPHRD_INFINIBAND:
213 ip_ib_mc_map(addr, dev->broadcast, haddr);
217 memcpy(haddr, dev->broadcast, dev->addr_len);
225 static u32 arp_hash(const void *pkey, const struct net_device *dev)
227 return jhash_2words(*(u32 *)pkey, dev->ifindex, arp_tbl.hash_rnd);
230 static int arp_constructor(struct neighbour *neigh)
232 __be32 addr = *(__be32*)neigh->primary_key;
233 struct net_device *dev = neigh->dev;
234 struct in_device *in_dev;
235 struct neigh_parms *parms;
238 in_dev = __in_dev_get_rcu(dev);
239 if (in_dev == NULL) {
244 neigh->type = inet_addr_type(dev_net(dev), addr);
246 parms = in_dev->arp_parms;
247 __neigh_parms_put(neigh->parms);
248 neigh->parms = neigh_parms_clone(parms);
251 if (!dev->header_ops) {
252 neigh->nud_state = NUD_NOARP;
253 neigh->ops = &arp_direct_ops;
254 neigh->output = neigh->ops->queue_xmit;
256 /* Good devices (checked by reading texts, but only Ethernet is
259 ARPHRD_ETHER: (ethernet, apfddi)
262 ARPHRD_METRICOM: (strip)
266 ARPHRD_IPDDP will also work, if author repairs it.
267 I did not it, because this driver does not work even
272 /* So... these "amateur" devices are hopeless.
273 The only thing, that I can say now:
274 It is very sad that we need to keep ugly obsolete
275 code to make them happy.
277 They should be moved to more reasonable state, now
278 they use rebuild_header INSTEAD OF hard_start_xmit!!!
279 Besides that, they are sort of out of date
280 (a lot of redundant clones/copies, useless in 2.1),
281 I wonder why people believe that they work.
287 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
289 #if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
292 neigh->ops = &arp_broken_ops;
293 neigh->output = neigh->ops->output;
298 if (neigh->type == RTN_MULTICAST) {
299 neigh->nud_state = NUD_NOARP;
300 arp_mc_map(addr, neigh->ha, dev, 1);
301 } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
302 neigh->nud_state = NUD_NOARP;
303 memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
304 } else if (neigh->type == RTN_BROADCAST || dev->flags&IFF_POINTOPOINT) {
305 neigh->nud_state = NUD_NOARP;
306 memcpy(neigh->ha, dev->broadcast, dev->addr_len);
309 if (dev->header_ops->cache)
310 neigh->ops = &arp_hh_ops;
312 neigh->ops = &arp_generic_ops;
314 if (neigh->nud_state&NUD_VALID)
315 neigh->output = neigh->ops->connected_output;
317 neigh->output = neigh->ops->output;
322 static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb)
324 dst_link_failure(skb);
328 static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb)
332 struct net_device *dev = neigh->dev;
333 __be32 target = *(__be32*)neigh->primary_key;
334 int probes = atomic_read(&neigh->probes);
335 struct in_device *in_dev = in_dev_get(dev);
340 switch (IN_DEV_ARP_ANNOUNCE(in_dev)) {
342 case 0: /* By default announce any local IP */
343 if (skb && inet_addr_type(dev_net(dev), ip_hdr(skb)->saddr) == RTN_LOCAL)
344 saddr = ip_hdr(skb)->saddr;
346 case 1: /* Restrict announcements of saddr in same subnet */
349 saddr = ip_hdr(skb)->saddr;
350 if (inet_addr_type(dev_net(dev), saddr) == RTN_LOCAL) {
351 /* saddr should be known to target */
352 if (inet_addr_onlink(in_dev, target, saddr))
357 case 2: /* Avoid secondary IPs, get a primary/preferred one */
364 saddr = inet_select_addr(dev, target, RT_SCOPE_LINK);
366 if ((probes -= neigh->parms->ucast_probes) < 0) {
367 if (!(neigh->nud_state&NUD_VALID))
368 printk(KERN_DEBUG "trying to ucast probe in NUD_INVALID\n");
370 read_lock_bh(&neigh->lock);
371 } else if ((probes -= neigh->parms->app_probes) < 0) {
378 arp_send(ARPOP_REQUEST, ETH_P_ARP, target, dev, saddr,
379 dst_ha, dev->dev_addr, NULL);
381 read_unlock_bh(&neigh->lock);
384 static int arp_ignore(struct in_device *in_dev, __be32 sip, __be32 tip)
388 switch (IN_DEV_ARP_IGNORE(in_dev)) {
389 case 0: /* Reply, the tip is already validated */
391 case 1: /* Reply only if tip is configured on the incoming interface */
393 scope = RT_SCOPE_HOST;
396 * Reply only if tip is configured on the incoming interface
397 * and is in same subnet as sip
399 scope = RT_SCOPE_HOST;
401 case 3: /* Do not reply for scope host addresses */
403 scope = RT_SCOPE_LINK;
405 case 4: /* Reserved */
410 case 8: /* Do not reply */
415 return !inet_confirm_addr(in_dev, sip, tip, scope);
418 static int arp_filter(__be32 sip, __be32 tip, struct net_device *dev)
420 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = sip,
424 /*unsigned long now; */
425 struct net *net = dev_net(dev);
427 if (ip_route_output_key(net, &rt, &fl) < 0)
429 if (rt->u.dst.dev != dev) {
430 NET_INC_STATS_BH(net, LINUX_MIB_ARPFILTER);
437 /* OBSOLETE FUNCTIONS */
440 * Find an arp mapping in the cache. If not found, post a request.
442 * It is very UGLY routine: it DOES NOT use skb->dst->neighbour,
443 * even if it exists. It is supposed that skb->dev was mangled
444 * by a virtual device (eql, shaper). Nobody but broken devices
445 * is allowed to use this function, it is scheduled to be removed. --ANK
448 static int arp_set_predefined(int addr_hint, unsigned char * haddr, __be32 paddr, struct net_device * dev)
452 printk(KERN_DEBUG "ARP: arp called for own IP address\n");
453 memcpy(haddr, dev->dev_addr, dev->addr_len);
456 arp_mc_map(paddr, haddr, dev, 1);
459 memcpy(haddr, dev->broadcast, dev->addr_len);
466 int arp_find(unsigned char *haddr, struct sk_buff *skb)
468 struct net_device *dev = skb->dev;
473 printk(KERN_DEBUG "arp_find is called with dst==NULL\n");
478 paddr = skb_rtable(skb)->rt_gateway;
480 if (arp_set_predefined(inet_addr_type(dev_net(dev), paddr), haddr, paddr, dev))
483 n = __neigh_lookup(&arp_tbl, &paddr, dev, 1);
487 if (n->nud_state&NUD_VALID || neigh_event_send(n, skb) == 0) {
488 read_lock_bh(&n->lock);
489 memcpy(haddr, n->ha, dev->addr_len);
490 read_unlock_bh(&n->lock);
500 /* END OF OBSOLETE FUNCTIONS */
502 int arp_bind_neighbour(struct dst_entry *dst)
504 struct net_device *dev = dst->dev;
505 struct neighbour *n = dst->neighbour;
510 __be32 nexthop = ((struct rtable *)dst)->rt_gateway;
511 if (dev->flags&(IFF_LOOPBACK|IFF_POINTOPOINT))
513 n = __neigh_lookup_errno(
514 #if defined(CONFIG_ATM_CLIP) || defined(CONFIG_ATM_CLIP_MODULE)
515 dev->type == ARPHRD_ATM ? clip_tbl_hook :
517 &arp_tbl, &nexthop, dev);
526 * Check if we can use proxy ARP for this path
528 static inline int arp_fwd_proxy(struct in_device *in_dev,
529 struct net_device *dev, struct rtable *rt)
531 struct in_device *out_dev;
534 if (rt->u.dst.dev == dev)
537 if (!IN_DEV_PROXY_ARP(in_dev))
540 if ((imi = IN_DEV_MEDIUM_ID(in_dev)) == 0)
545 /* place to check for proxy_arp for routes */
547 if ((out_dev = in_dev_get(rt->u.dst.dev)) != NULL) {
548 omi = IN_DEV_MEDIUM_ID(out_dev);
551 return (omi != imi && omi != -1);
555 * Check for RFC3069 proxy arp private VLAN (allow to send back to same dev)
557 * RFC3069 supports proxy arp replies back to the same interface. This
558 * is done to support (ethernet) switch features, like RFC 3069, where
559 * the individual ports are not allowed to communicate with each
560 * other, BUT they are allowed to talk to the upstream router. As
561 * described in RFC 3069, it is possible to allow these hosts to
562 * communicate through the upstream router, by proxy_arp'ing.
564 * RFC 3069: "VLAN Aggregation for Efficient IP Address Allocation"
566 * This technology is known by different names:
567 * In RFC 3069 it is called VLAN Aggregation.
568 * Cisco and Allied Telesyn call it Private VLAN.
569 * Hewlett-Packard call it Source-Port filtering or port-isolation.
570 * Ericsson call it MAC-Forced Forwarding (RFC Draft).
573 static inline int arp_fwd_pvlan(struct in_device *in_dev,
574 struct net_device *dev, struct rtable *rt,
575 __be32 sip, __be32 tip)
577 /* Private VLAN is only concerned about the same ethernet segment */
578 if (rt->u.dst.dev != dev)
581 /* Don't reply on self probes (often done by windowz boxes)*/
585 if (IN_DEV_PROXY_ARP_PVLAN(in_dev))
592 * Interface to link layer: send routine and receive handler.
596 * Create an arp packet. If (dest_hw == NULL), we create a broadcast
599 struct sk_buff *arp_create(int type, int ptype, __be32 dest_ip,
600 struct net_device *dev, __be32 src_ip,
601 const unsigned char *dest_hw,
602 const unsigned char *src_hw,
603 const unsigned char *target_hw)
607 unsigned char *arp_ptr;
613 skb = alloc_skb(arp_hdr_len(dev) + LL_ALLOCATED_SPACE(dev), GFP_ATOMIC);
617 skb_reserve(skb, LL_RESERVED_SPACE(dev));
618 skb_reset_network_header(skb);
619 arp = (struct arphdr *) skb_put(skb, arp_hdr_len(dev));
621 skb->protocol = htons(ETH_P_ARP);
623 src_hw = dev->dev_addr;
625 dest_hw = dev->broadcast;
628 * Fill the device header for the ARP frame
630 if (dev_hard_header(skb, dev, ptype, dest_hw, src_hw, skb->len) < 0)
634 * Fill out the arp protocol part.
636 * The arp hardware type should match the device type, except for FDDI,
637 * which (according to RFC 1390) should always equal 1 (Ethernet).
640 * Exceptions everywhere. AX.25 uses the AX.25 PID value not the
641 * DIX code for the protocol. Make these device structure fields.
645 arp->ar_hrd = htons(dev->type);
646 arp->ar_pro = htons(ETH_P_IP);
649 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
651 arp->ar_hrd = htons(ARPHRD_AX25);
652 arp->ar_pro = htons(AX25_P_IP);
655 #if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
657 arp->ar_hrd = htons(ARPHRD_NETROM);
658 arp->ar_pro = htons(AX25_P_IP);
665 arp->ar_hrd = htons(ARPHRD_ETHER);
666 arp->ar_pro = htons(ETH_P_IP);
670 case ARPHRD_IEEE802_TR:
671 arp->ar_hrd = htons(ARPHRD_IEEE802);
672 arp->ar_pro = htons(ETH_P_IP);
677 arp->ar_hln = dev->addr_len;
679 arp->ar_op = htons(type);
681 arp_ptr=(unsigned char *)(arp+1);
683 memcpy(arp_ptr, src_hw, dev->addr_len);
684 arp_ptr += dev->addr_len;
685 memcpy(arp_ptr, &src_ip, 4);
687 if (target_hw != NULL)
688 memcpy(arp_ptr, target_hw, dev->addr_len);
690 memset(arp_ptr, 0, dev->addr_len);
691 arp_ptr += dev->addr_len;
692 memcpy(arp_ptr, &dest_ip, 4);
702 * Send an arp packet.
704 void arp_xmit(struct sk_buff *skb)
706 /* Send it off, maybe filter it using firewalling first. */
707 NF_HOOK(NFPROTO_ARP, NF_ARP_OUT, skb, NULL, skb->dev, dev_queue_xmit);
711 * Create and send an arp packet.
713 void arp_send(int type, int ptype, __be32 dest_ip,
714 struct net_device *dev, __be32 src_ip,
715 const unsigned char *dest_hw, const unsigned char *src_hw,
716 const unsigned char *target_hw)
721 * No arp on this interface.
724 if (dev->flags&IFF_NOARP)
727 skb = arp_create(type, ptype, dest_ip, dev, src_ip,
728 dest_hw, src_hw, target_hw);
737 * Process an arp request.
740 static int arp_process(struct sk_buff *skb)
742 struct net_device *dev = skb->dev;
743 struct in_device *in_dev = in_dev_get(dev);
745 unsigned char *arp_ptr;
749 u16 dev_type = dev->type;
752 struct net *net = dev_net(dev);
754 /* arp_rcv below verifies the ARP header and verifies the device
765 if (arp->ar_pro != htons(ETH_P_IP) ||
766 htons(dev_type) != arp->ar_hrd)
770 case ARPHRD_IEEE802_TR:
774 * ETHERNET, Token Ring and Fibre Channel (which are IEEE 802
775 * devices, according to RFC 2625) devices will accept ARP
776 * hardware types of either 1 (Ethernet) or 6 (IEEE 802.2).
777 * This is the case also of FDDI, where the RFC 1390 says that
778 * FDDI devices should accept ARP hardware of (1) Ethernet,
779 * however, to be more robust, we'll accept both 1 (Ethernet)
782 if ((arp->ar_hrd != htons(ARPHRD_ETHER) &&
783 arp->ar_hrd != htons(ARPHRD_IEEE802)) ||
784 arp->ar_pro != htons(ETH_P_IP))
788 if (arp->ar_pro != htons(AX25_P_IP) ||
789 arp->ar_hrd != htons(ARPHRD_AX25))
793 if (arp->ar_pro != htons(AX25_P_IP) ||
794 arp->ar_hrd != htons(ARPHRD_NETROM))
799 /* Understand only these message types */
801 if (arp->ar_op != htons(ARPOP_REPLY) &&
802 arp->ar_op != htons(ARPOP_REQUEST))
808 arp_ptr= (unsigned char *)(arp+1);
810 arp_ptr += dev->addr_len;
811 memcpy(&sip, arp_ptr, 4);
813 arp_ptr += dev->addr_len;
814 memcpy(&tip, arp_ptr, 4);
816 * Check for bad requests for 127.x.x.x and requests for multicast
817 * addresses. If this is one such, delete it.
819 if (ipv4_is_loopback(tip) || ipv4_is_multicast(tip))
823 * Special case: We must set Frame Relay source Q.922 address
825 if (dev_type == ARPHRD_DLCI)
826 sha = dev->broadcast;
829 * Process entry. The idea here is we want to send a reply if it is a
830 * request for us or if it is a request for someone else that we hold
831 * a proxy for. We want to add an entry to our cache if it is a reply
832 * to us or if it is a request for our address.
833 * (The assumption for this last is that if someone is requesting our
834 * address, they are probably intending to talk to us, so it saves time
835 * if we cache their address. Their address is also probably not in
836 * our cache, since ours is not in their cache.)
838 * Putting this another way, we only care about replies if they are to
839 * us, in which case we add them to the cache. For requests, we care
840 * about those for us and those for our proxies. We reply to both,
841 * and in the case of requests for us we add the requester to the arp
845 /* Special case: IPv4 duplicate address detection packet (RFC2131) */
847 if (arp->ar_op == htons(ARPOP_REQUEST) &&
848 inet_addr_type(net, tip) == RTN_LOCAL &&
849 !arp_ignore(in_dev, sip, tip))
850 arp_send(ARPOP_REPLY, ETH_P_ARP, sip, dev, tip, sha,
855 if (arp->ar_op == htons(ARPOP_REQUEST) &&
856 ip_route_input(skb, tip, sip, 0, dev) == 0) {
858 rt = skb_rtable(skb);
859 addr_type = rt->rt_type;
861 if (addr_type == RTN_LOCAL) {
865 dont_send |= arp_ignore(in_dev,sip,tip);
866 if (!dont_send && IN_DEV_ARPFILTER(in_dev))
867 dont_send |= arp_filter(sip,tip,dev);
869 n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
871 arp_send(ARPOP_REPLY,ETH_P_ARP,sip,dev,tip,sha,dev->dev_addr,sha);
876 } else if (IN_DEV_FORWARD(in_dev)) {
877 if (addr_type == RTN_UNICAST &&
878 (arp_fwd_proxy(in_dev, dev, rt) ||
879 arp_fwd_pvlan(in_dev, dev, rt, sip, tip) ||
880 pneigh_lookup(&arp_tbl, net, &tip, dev, 0)))
882 n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
886 if (NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED ||
887 skb->pkt_type == PACKET_HOST ||
888 in_dev->arp_parms->proxy_delay == 0) {
889 arp_send(ARPOP_REPLY,ETH_P_ARP,sip,dev,tip,sha,dev->dev_addr,sha);
891 pneigh_enqueue(&arp_tbl, in_dev->arp_parms, skb);
900 /* Update our ARP tables */
902 n = __neigh_lookup(&arp_tbl, &sip, dev, 0);
904 if (IPV4_DEVCONF_ALL(dev_net(dev), ARP_ACCEPT)) {
905 /* Unsolicited ARP is not accepted by default.
906 It is possible, that this option should be enabled for some
907 devices (strip is candidate)
910 arp->ar_op == htons(ARPOP_REPLY) &&
911 inet_addr_type(net, sip) == RTN_UNICAST)
912 n = __neigh_lookup(&arp_tbl, &sip, dev, 1);
916 int state = NUD_REACHABLE;
919 /* If several different ARP replies follows back-to-back,
920 use the FIRST one. It is possible, if several proxy
921 agents are active. Taking the first reply prevents
922 arp trashing and chooses the fastest router.
924 override = time_after(jiffies, n->updated + n->parms->locktime);
926 /* Broadcast replies and request packets
927 do not assert neighbour reachability.
929 if (arp->ar_op != htons(ARPOP_REPLY) ||
930 skb->pkt_type != PACKET_HOST)
932 neigh_update(n, sha, state, override ? NEIGH_UPDATE_F_OVERRIDE : 0);
943 static void parp_redo(struct sk_buff *skb)
950 * Receive an arp request from the device layer.
953 static int arp_rcv(struct sk_buff *skb, struct net_device *dev,
954 struct packet_type *pt, struct net_device *orig_dev)
958 /* ARP header, plus 2 device addresses, plus 2 IP addresses. */
959 if (!pskb_may_pull(skb, arp_hdr_len(dev)))
963 if (arp->ar_hln != dev->addr_len ||
964 dev->flags & IFF_NOARP ||
965 skb->pkt_type == PACKET_OTHERHOST ||
966 skb->pkt_type == PACKET_LOOPBACK ||
970 if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
973 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
975 return NF_HOOK(NFPROTO_ARP, NF_ARP_IN, skb, dev, NULL, arp_process);
984 * User level interface (ioctl)
988 * Set (create) an ARP cache entry.
991 static int arp_req_set_proxy(struct net *net, struct net_device *dev, int on)
994 IPV4_DEVCONF_ALL(net, PROXY_ARP) = on;
997 if (__in_dev_get_rtnl(dev)) {
998 IN_DEV_CONF_SET(__in_dev_get_rtnl(dev), PROXY_ARP, on);
1004 static int arp_req_set_public(struct net *net, struct arpreq *r,
1005 struct net_device *dev)
1007 __be32 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
1008 __be32 mask = ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr;
1010 if (mask && mask != htonl(0xFFFFFFFF))
1012 if (!dev && (r->arp_flags & ATF_COM)) {
1013 dev = dev_getbyhwaddr(net, r->arp_ha.sa_family,
1019 if (pneigh_lookup(&arp_tbl, net, &ip, dev, 1) == NULL)
1024 return arp_req_set_proxy(net, dev, 1);
1027 static int arp_req_set(struct net *net, struct arpreq *r,
1028 struct net_device * dev)
1031 struct neighbour *neigh;
1034 if (r->arp_flags & ATF_PUBL)
1035 return arp_req_set_public(net, r, dev);
1037 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
1038 if (r->arp_flags & ATF_PERM)
1039 r->arp_flags |= ATF_COM;
1041 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = ip,
1042 .tos = RTO_ONLINK } } };
1044 if ((err = ip_route_output_key(net, &rt, &fl)) != 0)
1046 dev = rt->u.dst.dev;
1051 switch (dev->type) {
1055 * According to RFC 1390, FDDI devices should accept ARP
1056 * hardware types of 1 (Ethernet). However, to be more
1057 * robust, we'll accept hardware types of either 1 (Ethernet)
1058 * or 6 (IEEE 802.2).
1060 if (r->arp_ha.sa_family != ARPHRD_FDDI &&
1061 r->arp_ha.sa_family != ARPHRD_ETHER &&
1062 r->arp_ha.sa_family != ARPHRD_IEEE802)
1067 if (r->arp_ha.sa_family != dev->type)
1072 neigh = __neigh_lookup_errno(&arp_tbl, &ip, dev);
1073 err = PTR_ERR(neigh);
1074 if (!IS_ERR(neigh)) {
1075 unsigned state = NUD_STALE;
1076 if (r->arp_flags & ATF_PERM)
1077 state = NUD_PERMANENT;
1078 err = neigh_update(neigh, (r->arp_flags&ATF_COM) ?
1079 r->arp_ha.sa_data : NULL, state,
1080 NEIGH_UPDATE_F_OVERRIDE|
1081 NEIGH_UPDATE_F_ADMIN);
1082 neigh_release(neigh);
1087 static unsigned arp_state_to_flags(struct neighbour *neigh)
1090 if (neigh->nud_state&NUD_PERMANENT)
1091 flags = ATF_PERM|ATF_COM;
1092 else if (neigh->nud_state&NUD_VALID)
1098 * Get an ARP cache entry.
1101 static int arp_req_get(struct arpreq *r, struct net_device *dev)
1103 __be32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
1104 struct neighbour *neigh;
1107 neigh = neigh_lookup(&arp_tbl, &ip, dev);
1109 read_lock_bh(&neigh->lock);
1110 memcpy(r->arp_ha.sa_data, neigh->ha, dev->addr_len);
1111 r->arp_flags = arp_state_to_flags(neigh);
1112 read_unlock_bh(&neigh->lock);
1113 r->arp_ha.sa_family = dev->type;
1114 strlcpy(r->arp_dev, dev->name, sizeof(r->arp_dev));
1115 neigh_release(neigh);
1121 static int arp_req_delete_public(struct net *net, struct arpreq *r,
1122 struct net_device *dev)
1124 __be32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
1125 __be32 mask = ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr;
1127 if (mask == htonl(0xFFFFFFFF))
1128 return pneigh_delete(&arp_tbl, net, &ip, dev);
1133 return arp_req_set_proxy(net, dev, 0);
1136 static int arp_req_delete(struct net *net, struct arpreq *r,
1137 struct net_device * dev)
1141 struct neighbour *neigh;
1143 if (r->arp_flags & ATF_PUBL)
1144 return arp_req_delete_public(net, r, dev);
1146 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
1148 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = ip,
1149 .tos = RTO_ONLINK } } };
1151 if ((err = ip_route_output_key(net, &rt, &fl)) != 0)
1153 dev = rt->u.dst.dev;
1159 neigh = neigh_lookup(&arp_tbl, &ip, dev);
1161 if (neigh->nud_state&~NUD_NOARP)
1162 err = neigh_update(neigh, NULL, NUD_FAILED,
1163 NEIGH_UPDATE_F_OVERRIDE|
1164 NEIGH_UPDATE_F_ADMIN);
1165 neigh_release(neigh);
1171 * Handle an ARP layer I/O control request.
1174 int arp_ioctl(struct net *net, unsigned int cmd, void __user *arg)
1178 struct net_device *dev = NULL;
1183 if (!capable(CAP_NET_ADMIN))
1186 err = copy_from_user(&r, arg, sizeof(struct arpreq));
1194 if (r.arp_pa.sa_family != AF_INET)
1195 return -EPFNOSUPPORT;
1197 if (!(r.arp_flags & ATF_PUBL) &&
1198 (r.arp_flags & (ATF_NETMASK|ATF_DONTPUB)))
1200 if (!(r.arp_flags & ATF_NETMASK))
1201 ((struct sockaddr_in *)&r.arp_netmask)->sin_addr.s_addr =
1202 htonl(0xFFFFFFFFUL);
1206 if ((dev = __dev_get_by_name(net, r.arp_dev)) == NULL)
1209 /* Mmmm... It is wrong... ARPHRD_NETROM==0 */
1210 if (!r.arp_ha.sa_family)
1211 r.arp_ha.sa_family = dev->type;
1213 if ((r.arp_flags & ATF_COM) && r.arp_ha.sa_family != dev->type)
1215 } else if (cmd == SIOCGARP) {
1222 err = arp_req_delete(net, &r, dev);
1225 err = arp_req_set(net, &r, dev);
1228 err = arp_req_get(&r, dev);
1229 if (!err && copy_to_user(arg, &r, sizeof(r)))
1238 static int arp_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1240 struct net_device *dev = ptr;
1243 case NETDEV_CHANGEADDR:
1244 neigh_changeaddr(&arp_tbl, dev);
1245 rt_cache_flush(dev_net(dev), 0);
1254 static struct notifier_block arp_netdev_notifier = {
1255 .notifier_call = arp_netdev_event,
1258 /* Note, that it is not on notifier chain.
1259 It is necessary, that this routine was called after route cache will be
1262 void arp_ifdown(struct net_device *dev)
1264 neigh_ifdown(&arp_tbl, dev);
1269 * Called once on startup.
1272 static struct packet_type arp_packet_type __read_mostly = {
1273 .type = cpu_to_be16(ETH_P_ARP),
1277 static int arp_proc_init(void);
1279 void __init arp_init(void)
1281 neigh_table_init(&arp_tbl);
1283 dev_add_pack(&arp_packet_type);
1285 #ifdef CONFIG_SYSCTL
1286 neigh_sysctl_register(NULL, &arp_tbl.parms, NET_IPV4,
1287 NET_IPV4_NEIGH, "ipv4", NULL);
1289 register_netdevice_notifier(&arp_netdev_notifier);
1292 #ifdef CONFIG_PROC_FS
1293 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1295 /* ------------------------------------------------------------------------ */
1297 * ax25 -> ASCII conversion
1299 static char *ax2asc2(ax25_address *a, char *buf)
1304 for (n = 0, s = buf; n < 6; n++) {
1305 c = (a->ax25_call[n] >> 1) & 0x7F;
1307 if (c != ' ') *s++ = c;
1312 if ((n = ((a->ax25_call[6] >> 1) & 0x0F)) > 9) {
1320 if (*buf == '\0' || *buf == '-')
1326 #endif /* CONFIG_AX25 */
1328 #define HBUFFERLEN 30
1330 static void arp_format_neigh_entry(struct seq_file *seq,
1331 struct neighbour *n)
1333 char hbuffer[HBUFFERLEN];
1336 struct net_device *dev = n->dev;
1337 int hatype = dev->type;
1339 read_lock(&n->lock);
1340 /* Convert hardware address to XX:XX:XX:XX ... form. */
1341 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1342 if (hatype == ARPHRD_AX25 || hatype == ARPHRD_NETROM)
1343 ax2asc2((ax25_address *)n->ha, hbuffer);
1346 for (k = 0, j = 0; k < HBUFFERLEN - 3 && j < dev->addr_len; j++) {
1347 hbuffer[k++] = hex_asc_hi(n->ha[j]);
1348 hbuffer[k++] = hex_asc_lo(n->ha[j]);
1354 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1357 sprintf(tbuf, "%pI4", n->primary_key);
1358 seq_printf(seq, "%-16s 0x%-10x0x%-10x%s * %s\n",
1359 tbuf, hatype, arp_state_to_flags(n), hbuffer, dev->name);
1360 read_unlock(&n->lock);
1363 static void arp_format_pneigh_entry(struct seq_file *seq,
1364 struct pneigh_entry *n)
1366 struct net_device *dev = n->dev;
1367 int hatype = dev ? dev->type : 0;
1370 sprintf(tbuf, "%pI4", n->key);
1371 seq_printf(seq, "%-16s 0x%-10x0x%-10x%s * %s\n",
1372 tbuf, hatype, ATF_PUBL | ATF_PERM, "00:00:00:00:00:00",
1373 dev ? dev->name : "*");
1376 static int arp_seq_show(struct seq_file *seq, void *v)
1378 if (v == SEQ_START_TOKEN) {
1379 seq_puts(seq, "IP address HW type Flags "
1380 "HW address Mask Device\n");
1382 struct neigh_seq_state *state = seq->private;
1384 if (state->flags & NEIGH_SEQ_IS_PNEIGH)
1385 arp_format_pneigh_entry(seq, v);
1387 arp_format_neigh_entry(seq, v);
1393 static void *arp_seq_start(struct seq_file *seq, loff_t *pos)
1395 /* Don't want to confuse "arp -a" w/ magic entries,
1396 * so we tell the generic iterator to skip NUD_NOARP.
1398 return neigh_seq_start(seq, pos, &arp_tbl, NEIGH_SEQ_SKIP_NOARP);
1401 /* ------------------------------------------------------------------------ */
1403 static const struct seq_operations arp_seq_ops = {
1404 .start = arp_seq_start,
1405 .next = neigh_seq_next,
1406 .stop = neigh_seq_stop,
1407 .show = arp_seq_show,
1410 static int arp_seq_open(struct inode *inode, struct file *file)
1412 return seq_open_net(inode, file, &arp_seq_ops,
1413 sizeof(struct neigh_seq_state));
1416 static const struct file_operations arp_seq_fops = {
1417 .owner = THIS_MODULE,
1418 .open = arp_seq_open,
1420 .llseek = seq_lseek,
1421 .release = seq_release_net,
1425 static int __net_init arp_net_init(struct net *net)
1427 if (!proc_net_fops_create(net, "arp", S_IRUGO, &arp_seq_fops))
1432 static void __net_exit arp_net_exit(struct net *net)
1434 proc_net_remove(net, "arp");
1437 static struct pernet_operations arp_net_ops = {
1438 .init = arp_net_init,
1439 .exit = arp_net_exit,
1442 static int __init arp_proc_init(void)
1444 return register_pernet_subsys(&arp_net_ops);
1447 #else /* CONFIG_PROC_FS */
1449 static int __init arp_proc_init(void)
1454 #endif /* CONFIG_PROC_FS */
1456 EXPORT_SYMBOL(arp_broken_ops);
1457 EXPORT_SYMBOL(arp_find);
1458 EXPORT_SYMBOL(arp_create);
1459 EXPORT_SYMBOL(arp_xmit);
1460 EXPORT_SYMBOL(arp_send);
1461 EXPORT_SYMBOL(arp_tbl);
1463 #if defined(CONFIG_ATM_CLIP) || defined(CONFIG_ATM_CLIP_MODULE)
1464 EXPORT_SYMBOL(clip_tbl_hook);