blob: 18d9b81ecb1ac2a61d53b492a81781ad0bcfc2d8 [file] [log] [blame]
Uwe Zeisbergerf30c2262006-10-03 23:01:26 +02001/* linux/net/ipv4/arp.c
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 * Copyright (C) 1994 by Florian La Roche
4 *
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
8 * address).
9 *
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.
14 *
15 * Fixes:
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090016 * Alan Cox : Removed the Ethernet assumptions in
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 * Florian's code
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090018 * Alan Cox : Fixed some small errors in the ARP
Linus Torvalds1da177e2005-04-16 15:20:36 -070019 * logic
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.
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090040 * Craig Schlenter : Don't modify permanent entry
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 * during arp_rcv.
42 * Russ Nelson : Tidied up a few bits.
43 * Alexey Kuznetsov: Major changes to caching and behaviour,
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090044 * eg intelligent arp probing and
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 * generation
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.
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090051 * Jonathan Layes : Added arpd support through kerneld
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 * 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.
Changli Gaodeffd772010-09-02 03:56:51 +000058 * Alan Cox : Took the AP1000 nasty FDDI hack and
Linus Torvalds1da177e2005-04-16 15:20:36 -070059 * folded into the mainstream FDDI code.
60 * Ack spit, Linus how did you allow that
61 * one in...
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
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +000073 * Jesper D. Brouer: Proxy ARP PVLAN RFC 3069 support.
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 */
75
76#include <linux/module.h>
77#include <linux/types.h>
78#include <linux/string.h>
79#include <linux/kernel.h>
Randy Dunlap4fc268d2006-01-11 12:17:47 -080080#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070081#include <linux/socket.h>
82#include <linux/sockios.h>
83#include <linux/errno.h>
84#include <linux/in.h>
85#include <linux/mm.h>
86#include <linux/inet.h>
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020087#include <linux/inetdevice.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070088#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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +0900100#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101#ifdef CONFIG_SYSCTL
102#include <linux/sysctl.h>
103#endif
104
Eric W. Biederman457c4cb2007-09-12 12:01:34 +0200105#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106#include <net/ip.h>
107#include <net/icmp.h>
108#include <net/route.h>
109#include <net/protocol.h>
110#include <net/tcp.h>
111#include <net/sock.h>
112#include <net/arp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113#include <net/ax25.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114#include <net/netrom.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115
Changli Gaodeffd772010-09-02 03:56:51 +0000116#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
118#include <linux/netfilter_arp.h>
119
120/*
121 * Interface to generic neighbour cache.
122 */
David S. Miller2c2aba62011-12-28 15:06:58 -0500123static u32 arp_hash(const void *pkey, const struct net_device *dev, __u32 *hash_rnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124static int arp_constructor(struct neighbour *neigh);
125static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb);
126static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb);
127static void parp_redo(struct sk_buff *skb);
128
Stephen Hemminger89d69d22009-09-01 11:13:19 +0000129static const struct neigh_ops arp_generic_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 .family = AF_INET,
131 .solicit = arp_solicit,
132 .error_report = arp_error_report,
133 .output = neigh_resolve_output,
134 .connected_output = neigh_connected_output,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135};
136
Stephen Hemminger89d69d22009-09-01 11:13:19 +0000137static const struct neigh_ops arp_hh_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 .family = AF_INET,
139 .solicit = arp_solicit,
140 .error_report = arp_error_report,
141 .output = neigh_resolve_output,
142 .connected_output = neigh_resolve_output,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143};
144
Stephen Hemminger89d69d22009-09-01 11:13:19 +0000145static const struct neigh_ops arp_direct_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 .family = AF_INET,
David S. Miller8f40b162011-07-17 13:34:11 -0700147 .output = neigh_direct_output,
148 .connected_output = neigh_direct_output,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149};
150
stephen hemmingera64de472010-09-28 17:08:02 +0000151static const struct neigh_ops arp_broken_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 .family = AF_INET,
153 .solicit = arp_solicit,
154 .error_report = arp_error_report,
155 .output = neigh_compat_output,
156 .connected_output = neigh_compat_output,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157};
158
159struct neigh_table arp_tbl = {
Changli Gaodeffd772010-09-02 03:56:51 +0000160 .family = AF_INET,
Changli Gaodeffd772010-09-02 03:56:51 +0000161 .key_len = 4,
162 .hash = arp_hash,
163 .constructor = arp_constructor,
164 .proxy_redo = parp_redo,
165 .id = "arp_cache",
166 .parms = {
167 .tbl = &arp_tbl,
168 .base_reachable_time = 30 * HZ,
169 .retrans_time = 1 * HZ,
170 .gc_staletime = 60 * HZ,
171 .reachable_time = 30 * HZ,
172 .delay_probe_time = 5 * HZ,
Eric Dumazet8b5c1712011-11-09 12:07:14 +0000173 .queue_len_bytes = 64*1024,
Changli Gaodeffd772010-09-02 03:56:51 +0000174 .ucast_probes = 3,
175 .mcast_probes = 3,
176 .anycast_delay = 1 * HZ,
177 .proxy_delay = (8 * HZ) / 10,
178 .proxy_qlen = 64,
179 .locktime = 1 * HZ,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 },
Changli Gaodeffd772010-09-02 03:56:51 +0000181 .gc_interval = 30 * HZ,
182 .gc_thresh1 = 128,
183 .gc_thresh2 = 512,
184 .gc_thresh3 = 1024,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185};
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000186EXPORT_SYMBOL(arp_tbl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
Al Viro714e85b2006-11-14 20:51:49 -0800188int arp_mc_map(__be32 addr, u8 *haddr, struct net_device *dev, int dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189{
190 switch (dev->type) {
191 case ARPHRD_ETHER:
192 case ARPHRD_FDDI:
193 case ARPHRD_IEEE802:
194 ip_eth_mc_map(addr, haddr);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900195 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 case ARPHRD_IEEE802_TR:
197 ip_tr_mc_map(addr, haddr);
198 return 0;
199 case ARPHRD_INFINIBAND:
Rolf Manderscheida9e527e2007-12-10 13:38:41 -0700200 ip_ib_mc_map(addr, dev->broadcast, haddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 return 0;
Timo Teräs93ca3bb2011-03-28 22:40:53 +0000202 case ARPHRD_IPGRE:
203 ip_ipgre_mc_map(addr, dev->broadcast, haddr);
204 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 default:
206 if (dir) {
207 memcpy(haddr, dev->broadcast, dev->addr_len);
208 return 0;
209 }
210 }
211 return -EINVAL;
212}
213
214
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000215static u32 arp_hash(const void *pkey,
216 const struct net_device *dev,
David S. Miller2c2aba62011-12-28 15:06:58 -0500217 __u32 *hash_rnd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218{
David S. Miller2c2aba62011-12-28 15:06:58 -0500219 return arp_hashfn(*(u32 *)pkey, dev, *hash_rnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220}
221
222static int arp_constructor(struct neighbour *neigh)
223{
Changli Gaodeffd772010-09-02 03:56:51 +0000224 __be32 addr = *(__be32 *)neigh->primary_key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 struct net_device *dev = neigh->dev;
226 struct in_device *in_dev;
227 struct neigh_parms *parms;
228
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 rcu_read_lock();
Herbert Xue5ed6392005-10-03 14:35:55 -0700230 in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 if (in_dev == NULL) {
232 rcu_read_unlock();
233 return -EINVAL;
234 }
235
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900236 neigh->type = inet_addr_type(dev_net(dev), addr);
Denis V. Luneva79878f2008-01-14 22:56:01 -0800237
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 parms = in_dev->arp_parms;
239 __neigh_parms_put(neigh->parms);
240 neigh->parms = neigh_parms_clone(parms);
241 rcu_read_unlock();
242
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700243 if (!dev->header_ops) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 neigh->nud_state = NUD_NOARP;
245 neigh->ops = &arp_direct_ops;
David S. Miller8f40b162011-07-17 13:34:11 -0700246 neigh->output = neigh_direct_output;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 } else {
248 /* Good devices (checked by reading texts, but only Ethernet is
249 tested)
250
251 ARPHRD_ETHER: (ethernet, apfddi)
252 ARPHRD_FDDI: (fddi)
253 ARPHRD_IEEE802: (tr)
254 ARPHRD_METRICOM: (strip)
255 ARPHRD_ARCNET:
256 etc. etc. etc.
257
258 ARPHRD_IPDDP will also work, if author repairs it.
259 I did not it, because this driver does not work even
260 in old paradigm.
261 */
262
263#if 1
264 /* So... these "amateur" devices are hopeless.
265 The only thing, that I can say now:
266 It is very sad that we need to keep ugly obsolete
267 code to make them happy.
268
269 They should be moved to more reasonable state, now
270 they use rebuild_header INSTEAD OF hard_start_xmit!!!
271 Besides that, they are sort of out of date
272 (a lot of redundant clones/copies, useless in 2.1),
273 I wonder why people believe that they work.
274 */
275 switch (dev->type) {
276 default:
277 break;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900278 case ARPHRD_ROSE:
Igor Maravic40e47832011-12-05 02:25:57 +0000279#if IS_ENABLED(CONFIG_AX25)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 case ARPHRD_AX25:
Igor Maravic40e47832011-12-05 02:25:57 +0000281#if IS_ENABLED(CONFIG_NETROM)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 case ARPHRD_NETROM:
283#endif
284 neigh->ops = &arp_broken_ops;
285 neigh->output = neigh->ops->output;
286 return 0;
Changli Gaodeffd772010-09-02 03:56:51 +0000287#else
288 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289#endif
Changli Gaodeffd772010-09-02 03:56:51 +0000290 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291#endif
292 if (neigh->type == RTN_MULTICAST) {
293 neigh->nud_state = NUD_NOARP;
294 arp_mc_map(addr, neigh->ha, dev, 1);
Changli Gaodeffd772010-09-02 03:56:51 +0000295 } else if (dev->flags & (IFF_NOARP | IFF_LOOPBACK)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 neigh->nud_state = NUD_NOARP;
297 memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
Changli Gaodeffd772010-09-02 03:56:51 +0000298 } else if (neigh->type == RTN_BROADCAST ||
299 (dev->flags & IFF_POINTOPOINT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 neigh->nud_state = NUD_NOARP;
301 memcpy(neigh->ha, dev->broadcast, dev->addr_len);
302 }
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700303
304 if (dev->header_ops->cache)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 neigh->ops = &arp_hh_ops;
306 else
307 neigh->ops = &arp_generic_ops;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700308
Changli Gaodeffd772010-09-02 03:56:51 +0000309 if (neigh->nud_state & NUD_VALID)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 neigh->output = neigh->ops->connected_output;
311 else
312 neigh->output = neigh->ops->output;
313 }
314 return 0;
315}
316
317static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb)
318{
319 dst_link_failure(skb);
320 kfree_skb(skb);
321}
322
323static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb)
324{
Al Viroa61ced52006-09-26 21:27:54 -0700325 __be32 saddr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 u8 *dst_ha = NULL;
327 struct net_device *dev = neigh->dev;
Changli Gaodeffd772010-09-02 03:56:51 +0000328 __be32 target = *(__be32 *)neigh->primary_key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 int probes = atomic_read(&neigh->probes);
Eric Dumazet4b4194c2010-06-22 07:43:15 +0000330 struct in_device *in_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331
Eric Dumazet4b4194c2010-06-22 07:43:15 +0000332 rcu_read_lock();
333 in_dev = __in_dev_get_rcu(dev);
334 if (!in_dev) {
335 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 return;
Eric Dumazet4b4194c2010-06-22 07:43:15 +0000337 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 switch (IN_DEV_ARP_ANNOUNCE(in_dev)) {
339 default:
340 case 0: /* By default announce any local IP */
Changli Gaodeffd772010-09-02 03:56:51 +0000341 if (skb && inet_addr_type(dev_net(dev),
342 ip_hdr(skb)->saddr) == RTN_LOCAL)
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700343 saddr = ip_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 break;
345 case 1: /* Restrict announcements of saddr in same subnet */
346 if (!skb)
347 break;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700348 saddr = ip_hdr(skb)->saddr;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900349 if (inet_addr_type(dev_net(dev), saddr) == RTN_LOCAL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 /* saddr should be known to target */
351 if (inet_addr_onlink(in_dev, target, saddr))
352 break;
353 }
354 saddr = 0;
355 break;
356 case 2: /* Avoid secondary IPs, get a primary/preferred one */
357 break;
358 }
Eric Dumazet4b4194c2010-06-22 07:43:15 +0000359 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 if (!saddr)
362 saddr = inet_select_addr(dev, target, RT_SCOPE_LINK);
363
Changli Gaodeffd772010-09-02 03:56:51 +0000364 probes -= neigh->parms->ucast_probes;
365 if (probes < 0) {
366 if (!(neigh->nud_state & NUD_VALID))
367 printk(KERN_DEBUG
368 "trying to ucast probe in NUD_INVALID\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 dst_ha = neigh->ha;
David S. Miller9ff56602008-02-17 18:39:54 -0800370 read_lock_bh(&neigh->lock);
Changli Gaodeffd772010-09-02 03:56:51 +0000371 } else {
372 probes -= neigh->parms->app_probes;
373 if (probes < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374#ifdef CONFIG_ARPD
Changli Gaodeffd772010-09-02 03:56:51 +0000375 neigh_app_ns(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376#endif
Changli Gaodeffd772010-09-02 03:56:51 +0000377 return;
378 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 }
380
381 arp_send(ARPOP_REQUEST, ETH_P_ARP, target, dev, saddr,
382 dst_ha, dev->dev_addr, NULL);
David S. Miller9ff56602008-02-17 18:39:54 -0800383 if (dst_ha)
384 read_unlock_bh(&neigh->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385}
386
Denis V. Lunev9bd85e32008-01-14 23:05:55 -0800387static int arp_ignore(struct in_device *in_dev, __be32 sip, __be32 tip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388{
389 int scope;
390
391 switch (IN_DEV_ARP_IGNORE(in_dev)) {
392 case 0: /* Reply, the tip is already validated */
393 return 0;
394 case 1: /* Reply only if tip is configured on the incoming interface */
395 sip = 0;
396 scope = RT_SCOPE_HOST;
397 break;
398 case 2: /*
399 * Reply only if tip is configured on the incoming interface
400 * and is in same subnet as sip
401 */
402 scope = RT_SCOPE_HOST;
403 break;
404 case 3: /* Do not reply for scope host addresses */
405 sip = 0;
406 scope = RT_SCOPE_LINK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 break;
408 case 4: /* Reserved */
409 case 5:
410 case 6:
411 case 7:
412 return 0;
413 case 8: /* Do not reply */
414 return 1;
415 default:
416 return 0;
417 }
Denis V. Lunev9bd85e32008-01-14 23:05:55 -0800418 return !inet_confirm_addr(in_dev, sip, tip, scope);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419}
420
Al Viroed9bad02006-09-27 18:36:36 -0700421static int arp_filter(__be32 sip, __be32 tip, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 struct rtable *rt;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900424 int flag = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 /*unsigned long now; */
Pavel Emelyanovca12a1a2008-07-16 20:28:42 -0700426 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427
David S. Miller78fbfd82011-03-12 00:00:52 -0500428 rt = ip_route_output(net, sip, tip, 0, 0);
David S. Millerb23dd4f2011-03-02 14:31:35 -0800429 if (IS_ERR(rt))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 return 1;
Changli Gaod8d1f302010-06-10 23:31:35 -0700431 if (rt->dst.dev != dev) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700432 NET_INC_STATS_BH(net, LINUX_MIB_ARPFILTER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 flag = 1;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900434 }
435 ip_rt_put(rt);
436 return flag;
437}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438
439/* OBSOLETE FUNCTIONS */
440
441/*
442 * Find an arp mapping in the cache. If not found, post a request.
443 *
444 * It is very UGLY routine: it DOES NOT use skb->dst->neighbour,
445 * even if it exists. It is supposed that skb->dev was mangled
446 * by a virtual device (eql, shaper). Nobody but broken devices
447 * is allowed to use this function, it is scheduled to be removed. --ANK
448 */
449
Changli Gaodeffd772010-09-02 03:56:51 +0000450static int arp_set_predefined(int addr_hint, unsigned char *haddr,
451 __be32 paddr, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452{
453 switch (addr_hint) {
454 case RTN_LOCAL:
455 printk(KERN_DEBUG "ARP: arp called for own IP address\n");
456 memcpy(haddr, dev->dev_addr, dev->addr_len);
457 return 1;
458 case RTN_MULTICAST:
459 arp_mc_map(paddr, haddr, dev, 1);
460 return 1;
461 case RTN_BROADCAST:
462 memcpy(haddr, dev->broadcast, dev->addr_len);
463 return 1;
464 }
465 return 0;
466}
467
468
469int arp_find(unsigned char *haddr, struct sk_buff *skb)
470{
471 struct net_device *dev = skb->dev;
Al Virofd683222006-09-26 22:17:51 -0700472 __be32 paddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 struct neighbour *n;
474
Eric Dumazetadf30902009-06-02 05:19:30 +0000475 if (!skb_dst(skb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 printk(KERN_DEBUG "arp_find is called with dst==NULL\n");
477 kfree_skb(skb);
478 return 1;
479 }
480
Eric Dumazet511c3f92009-06-02 05:14:27 +0000481 paddr = skb_rtable(skb)->rt_gateway;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482
Changli Gaodeffd772010-09-02 03:56:51 +0000483 if (arp_set_predefined(inet_addr_type(dev_net(dev), paddr), haddr,
484 paddr, dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 return 0;
486
487 n = __neigh_lookup(&arp_tbl, &paddr, dev, 1);
488
489 if (n) {
490 n->used = jiffies;
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +0000491 if (n->nud_state & NUD_VALID || neigh_event_send(n, skb) == 0) {
492 neigh_ha_snapshot(haddr, n, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 neigh_release(n);
494 return 0;
495 }
496 neigh_release(n);
497 } else
498 kfree_skb(skb);
499 return 1;
500}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000501EXPORT_SYMBOL(arp_find);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502
503/* END OF OBSOLETE FUNCTIONS */
504
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505/*
506 * Check if we can use proxy ARP for this path
507 */
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +0000508static inline int arp_fwd_proxy(struct in_device *in_dev,
509 struct net_device *dev, struct rtable *rt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510{
511 struct in_device *out_dev;
512 int imi, omi = -1;
513
Changli Gaod8d1f302010-06-10 23:31:35 -0700514 if (rt->dst.dev == dev)
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +0000515 return 0;
516
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 if (!IN_DEV_PROXY_ARP(in_dev))
518 return 0;
Changli Gaodeffd772010-09-02 03:56:51 +0000519 imi = IN_DEV_MEDIUM_ID(in_dev);
520 if (imi == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 return 1;
522 if (imi == -1)
523 return 0;
524
525 /* place to check for proxy_arp for routes */
526
Changli Gaod8d1f302010-06-10 23:31:35 -0700527 out_dev = __in_dev_get_rcu(rt->dst.dev);
Eric Dumazetfaa9dcf2010-06-03 04:09:10 +0000528 if (out_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 omi = IN_DEV_MEDIUM_ID(out_dev);
Eric Dumazetfaa9dcf2010-06-03 04:09:10 +0000530
Eric Dumazeta02cec22010-09-22 20:43:57 +0000531 return omi != imi && omi != -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532}
533
534/*
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +0000535 * Check for RFC3069 proxy arp private VLAN (allow to send back to same dev)
536 *
537 * RFC3069 supports proxy arp replies back to the same interface. This
538 * is done to support (ethernet) switch features, like RFC 3069, where
539 * the individual ports are not allowed to communicate with each
540 * other, BUT they are allowed to talk to the upstream router. As
541 * described in RFC 3069, it is possible to allow these hosts to
542 * communicate through the upstream router, by proxy_arp'ing.
543 *
544 * RFC 3069: "VLAN Aggregation for Efficient IP Address Allocation"
545 *
546 * This technology is known by different names:
547 * In RFC 3069 it is called VLAN Aggregation.
548 * Cisco and Allied Telesyn call it Private VLAN.
549 * Hewlett-Packard call it Source-Port filtering or port-isolation.
550 * Ericsson call it MAC-Forced Forwarding (RFC Draft).
551 *
552 */
553static inline int arp_fwd_pvlan(struct in_device *in_dev,
554 struct net_device *dev, struct rtable *rt,
555 __be32 sip, __be32 tip)
556{
557 /* Private VLAN is only concerned about the same ethernet segment */
Changli Gaod8d1f302010-06-10 23:31:35 -0700558 if (rt->dst.dev != dev)
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +0000559 return 0;
560
561 /* Don't reply on self probes (often done by windowz boxes)*/
562 if (sip == tip)
563 return 0;
564
565 if (IN_DEV_PROXY_ARP_PVLAN(in_dev))
566 return 1;
567 else
568 return 0;
569}
570
571/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 * Interface to link layer: send routine and receive handler.
573 */
574
575/*
576 * Create an arp packet. If (dest_hw == NULL), we create a broadcast
577 * message.
578 */
Al Viroed9bad02006-09-27 18:36:36 -0700579struct sk_buff *arp_create(int type, int ptype, __be32 dest_ip,
580 struct net_device *dev, __be32 src_ip,
Jan Engelhardtabfdf1c2008-01-31 03:59:24 -0800581 const unsigned char *dest_hw,
582 const unsigned char *src_hw,
583 const unsigned char *target_hw)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584{
585 struct sk_buff *skb;
586 struct arphdr *arp;
587 unsigned char *arp_ptr;
Herbert Xu66088242011-11-18 02:20:04 +0000588 int hlen = LL_RESERVED_SPACE(dev);
589 int tlen = dev->needed_tailroom;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590
591 /*
592 * Allocate a buffer
593 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900594
Herbert Xu66088242011-11-18 02:20:04 +0000595 skb = alloc_skb(arp_hdr_len(dev) + hlen + tlen, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 if (skb == NULL)
597 return NULL;
598
Herbert Xu66088242011-11-18 02:20:04 +0000599 skb_reserve(skb, hlen);
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -0700600 skb_reset_network_header(skb);
Pavel Emelyanov988b7052008-03-03 12:20:57 -0800601 arp = (struct arphdr *) skb_put(skb, arp_hdr_len(dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 skb->dev = dev;
603 skb->protocol = htons(ETH_P_ARP);
604 if (src_hw == NULL)
605 src_hw = dev->dev_addr;
606 if (dest_hw == NULL)
607 dest_hw = dev->broadcast;
608
609 /*
610 * Fill the device header for the ARP frame
611 */
Stephen Hemminger0c4e8582007-10-09 01:36:32 -0700612 if (dev_hard_header(skb, dev, ptype, dest_hw, src_hw, skb->len) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 goto out;
614
615 /*
616 * Fill out the arp protocol part.
617 *
618 * The arp hardware type should match the device type, except for FDDI,
619 * which (according to RFC 1390) should always equal 1 (Ethernet).
620 */
621 /*
622 * Exceptions everywhere. AX.25 uses the AX.25 PID value not the
623 * DIX code for the protocol. Make these device structure fields.
624 */
625 switch (dev->type) {
626 default:
627 arp->ar_hrd = htons(dev->type);
628 arp->ar_pro = htons(ETH_P_IP);
629 break;
630
Igor Maravic40e47832011-12-05 02:25:57 +0000631#if IS_ENABLED(CONFIG_AX25)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 case ARPHRD_AX25:
633 arp->ar_hrd = htons(ARPHRD_AX25);
634 arp->ar_pro = htons(AX25_P_IP);
635 break;
636
Igor Maravic40e47832011-12-05 02:25:57 +0000637#if IS_ENABLED(CONFIG_NETROM)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 case ARPHRD_NETROM:
639 arp->ar_hrd = htons(ARPHRD_NETROM);
640 arp->ar_pro = htons(AX25_P_IP);
641 break;
642#endif
643#endif
644
Igor Maravic40e47832011-12-05 02:25:57 +0000645#if IS_ENABLED(CONFIG_FDDI)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 case ARPHRD_FDDI:
647 arp->ar_hrd = htons(ARPHRD_ETHER);
648 arp->ar_pro = htons(ETH_P_IP);
649 break;
650#endif
Igor Maravic40e47832011-12-05 02:25:57 +0000651#if IS_ENABLED(CONFIG_TR)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 case ARPHRD_IEEE802_TR:
653 arp->ar_hrd = htons(ARPHRD_IEEE802);
654 arp->ar_pro = htons(ETH_P_IP);
655 break;
656#endif
657 }
658
659 arp->ar_hln = dev->addr_len;
660 arp->ar_pln = 4;
661 arp->ar_op = htons(type);
662
Changli Gaodeffd772010-09-02 03:56:51 +0000663 arp_ptr = (unsigned char *)(arp + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
665 memcpy(arp_ptr, src_hw, dev->addr_len);
Jianjun Kongf4cca7f2008-11-03 02:48:14 -0800666 arp_ptr += dev->addr_len;
667 memcpy(arp_ptr, &src_ip, 4);
668 arp_ptr += 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 if (target_hw != NULL)
670 memcpy(arp_ptr, target_hw, dev->addr_len);
671 else
672 memset(arp_ptr, 0, dev->addr_len);
Jianjun Kongf4cca7f2008-11-03 02:48:14 -0800673 arp_ptr += dev->addr_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 memcpy(arp_ptr, &dest_ip, 4);
675
676 return skb;
677
678out:
679 kfree_skb(skb);
680 return NULL;
681}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000682EXPORT_SYMBOL(arp_create);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683
684/*
685 * Send an arp packet.
686 */
687void arp_xmit(struct sk_buff *skb)
688{
689 /* Send it off, maybe filter it using firewalling first. */
Jan Engelhardtfdc93142008-10-20 03:34:51 -0700690 NF_HOOK(NFPROTO_ARP, NF_ARP_OUT, skb, NULL, skb->dev, dev_queue_xmit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000692EXPORT_SYMBOL(arp_xmit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693
694/*
695 * Create and send an arp packet.
696 */
Al Viroed9bad02006-09-27 18:36:36 -0700697void arp_send(int type, int ptype, __be32 dest_ip,
698 struct net_device *dev, __be32 src_ip,
Jan Engelhardtabfdf1c2008-01-31 03:59:24 -0800699 const unsigned char *dest_hw, const unsigned char *src_hw,
700 const unsigned char *target_hw)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701{
702 struct sk_buff *skb;
703
704 /*
705 * No arp on this interface.
706 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900707
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 if (dev->flags&IFF_NOARP)
709 return;
710
711 skb = arp_create(type, ptype, dest_ip, dev, src_ip,
712 dest_hw, src_hw, target_hw);
Changli Gaodeffd772010-09-02 03:56:51 +0000713 if (skb == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715
716 arp_xmit(skb);
717}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000718EXPORT_SYMBOL(arp_send);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720/*
721 * Process an arp request.
722 */
723
724static int arp_process(struct sk_buff *skb)
725{
726 struct net_device *dev = skb->dev;
Eric Dumazetfaa9dcf2010-06-03 04:09:10 +0000727 struct in_device *in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 struct arphdr *arp;
729 unsigned char *arp_ptr;
730 struct rtable *rt;
Mark Rydene0260fe2007-12-19 23:38:11 -0800731 unsigned char *sha;
Al Viro9e12bb22006-09-26 21:25:20 -0700732 __be32 sip, tip;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 u16 dev_type = dev->type;
734 int addr_type;
735 struct neighbour *n;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900736 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737
738 /* arp_rcv below verifies the ARP header and verifies the device
739 * is ARP'able.
740 */
741
742 if (in_dev == NULL)
743 goto out;
744
Arnaldo Carvalho de Melod0a92be2007-03-12 20:56:31 -0300745 arp = arp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746
747 switch (dev_type) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900748 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 if (arp->ar_pro != htons(ETH_P_IP) ||
750 htons(dev_type) != arp->ar_hrd)
751 goto out;
752 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 case ARPHRD_ETHER:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 case ARPHRD_IEEE802_TR:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 case ARPHRD_FDDI:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 case ARPHRD_IEEE802:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 /*
758 * ETHERNET, Token Ring and Fibre Channel (which are IEEE 802
759 * devices, according to RFC 2625) devices will accept ARP
760 * hardware types of either 1 (Ethernet) or 6 (IEEE 802.2).
761 * This is the case also of FDDI, where the RFC 1390 says that
762 * FDDI devices should accept ARP hardware of (1) Ethernet,
763 * however, to be more robust, we'll accept both 1 (Ethernet)
764 * or 6 (IEEE 802.2)
765 */
766 if ((arp->ar_hrd != htons(ARPHRD_ETHER) &&
767 arp->ar_hrd != htons(ARPHRD_IEEE802)) ||
768 arp->ar_pro != htons(ETH_P_IP))
769 goto out;
770 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 case ARPHRD_AX25:
772 if (arp->ar_pro != htons(AX25_P_IP) ||
773 arp->ar_hrd != htons(ARPHRD_AX25))
774 goto out;
775 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 case ARPHRD_NETROM:
777 if (arp->ar_pro != htons(AX25_P_IP) ||
778 arp->ar_hrd != htons(ARPHRD_NETROM))
779 goto out;
780 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 }
782
783 /* Understand only these message types */
784
785 if (arp->ar_op != htons(ARPOP_REPLY) &&
786 arp->ar_op != htons(ARPOP_REQUEST))
787 goto out;
788
789/*
790 * Extract fields
791 */
Changli Gaodeffd772010-09-02 03:56:51 +0000792 arp_ptr = (unsigned char *)(arp + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 sha = arp_ptr;
794 arp_ptr += dev->addr_len;
795 memcpy(&sip, arp_ptr, 4);
796 arp_ptr += 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 arp_ptr += dev->addr_len;
798 memcpy(&tip, arp_ptr, 4);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900799/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 * Check for bad requests for 127.x.x.x and requests for multicast
801 * addresses. If this is one such, delete it.
802 */
Joe Perchesf97c1e02007-12-16 13:45:43 -0800803 if (ipv4_is_loopback(tip) || ipv4_is_multicast(tip))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 goto out;
805
806/*
807 * Special case: We must set Frame Relay source Q.922 address
808 */
809 if (dev_type == ARPHRD_DLCI)
810 sha = dev->broadcast;
811
812/*
813 * Process entry. The idea here is we want to send a reply if it is a
814 * request for us or if it is a request for someone else that we hold
815 * a proxy for. We want to add an entry to our cache if it is a reply
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900816 * to us or if it is a request for our address.
817 * (The assumption for this last is that if someone is requesting our
818 * address, they are probably intending to talk to us, so it saves time
819 * if we cache their address. Their address is also probably not in
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 * our cache, since ours is not in their cache.)
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900821 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 * Putting this another way, we only care about replies if they are to
823 * us, in which case we add them to the cache. For requests, we care
824 * about those for us and those for our proxies. We reply to both,
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900825 * and in the case of requests for us we add the requester to the arp
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 * cache.
827 */
828
Eric W. Biedermanf8a68e72009-06-30 16:27:17 +0000829 /* Special case: IPv4 duplicate address detection packet (RFC2131) */
830 if (sip == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 if (arp->ar_op == htons(ARPOP_REQUEST) &&
Denis V. Lunev49e8a272008-03-24 15:28:12 -0700832 inet_addr_type(net, tip) == RTN_LOCAL &&
Denis V. Lunev9bd85e32008-01-14 23:05:55 -0800833 !arp_ignore(in_dev, sip, tip))
Jonas Danielssonb4a98112007-11-20 17:38:16 -0800834 arp_send(ARPOP_REPLY, ETH_P_ARP, sip, dev, tip, sha,
835 dev->dev_addr, sha);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 goto out;
837 }
838
839 if (arp->ar_op == htons(ARPOP_REQUEST) &&
Eric Dumazet4a944452010-05-10 11:33:06 +0000840 ip_route_input_noref(skb, tip, sip, 0, dev) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841
Eric Dumazet511c3f92009-06-02 05:14:27 +0000842 rt = skb_rtable(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 addr_type = rt->rt_type;
844
845 if (addr_type == RTN_LOCAL) {
Changli Gaodeffd772010-09-02 03:56:51 +0000846 int dont_send;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847
Changli Gaodeffd772010-09-02 03:56:51 +0000848 dont_send = arp_ignore(in_dev, sip, tip);
Ben Greear8164f1b2008-11-16 19:19:38 -0800849 if (!dont_send && IN_DEV_ARPFILTER(in_dev))
Changli Gaoae9c4162010-12-01 20:07:31 +0000850 dont_send = arp_filter(sip, tip, dev);
Ben Greear8164f1b2008-11-16 19:19:38 -0800851 if (!dont_send) {
852 n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
853 if (n) {
Changli Gaodeffd772010-09-02 03:56:51 +0000854 arp_send(ARPOP_REPLY, ETH_P_ARP, sip,
855 dev, tip, sha, dev->dev_addr,
856 sha);
Ben Greear8164f1b2008-11-16 19:19:38 -0800857 neigh_release(n);
858 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 }
860 goto out;
861 } else if (IN_DEV_FORWARD(in_dev)) {
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +0000862 if (addr_type == RTN_UNICAST &&
863 (arp_fwd_proxy(in_dev, dev, rt) ||
864 arp_fwd_pvlan(in_dev, dev, rt, sip, tip) ||
Thomas Graf70620c42012-02-10 04:07:11 +0000865 (rt->dst.dev != dev &&
866 pneigh_lookup(&arp_tbl, net, &tip, dev, 0)))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
868 if (n)
869 neigh_release(n);
870
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900871 if (NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 skb->pkt_type == PACKET_HOST ||
873 in_dev->arp_parms->proxy_delay == 0) {
Changli Gaodeffd772010-09-02 03:56:51 +0000874 arp_send(ARPOP_REPLY, ETH_P_ARP, sip,
875 dev, tip, sha, dev->dev_addr,
876 sha);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 } else {
Changli Gaodeffd772010-09-02 03:56:51 +0000878 pneigh_enqueue(&arp_tbl,
879 in_dev->arp_parms, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 return 0;
881 }
882 goto out;
883 }
884 }
885 }
886
887 /* Update our ARP tables */
888
889 n = __neigh_lookup(&arp_tbl, &sip, dev, 0);
890
Neil Horman124d37e2012-03-15 05:25:58 +0000891 if (IN_DEV_ARP_ACCEPT(in_dev)) {
Neil Hormanabd596a2006-03-20 22:39:47 -0800892 /* Unsolicited ARP is not accepted by default.
893 It is possible, that this option should be enabled for some
894 devices (strip is candidate)
895 */
896 if (n == NULL &&
Octavian Purdila6d955182010-01-18 12:58:44 +0000897 (arp->ar_op == htons(ARPOP_REPLY) ||
898 (arp->ar_op == htons(ARPOP_REQUEST) && tip == sip)) &&
Denis V. Lunev49e8a272008-03-24 15:28:12 -0700899 inet_addr_type(net, sip) == RTN_UNICAST)
Jean Delvare1b1ac752007-07-14 20:51:44 -0700900 n = __neigh_lookup(&arp_tbl, &sip, dev, 1);
Neil Hormanabd596a2006-03-20 22:39:47 -0800901 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902
903 if (n) {
904 int state = NUD_REACHABLE;
905 int override;
906
907 /* If several different ARP replies follows back-to-back,
908 use the FIRST one. It is possible, if several proxy
909 agents are active. Taking the first reply prevents
910 arp trashing and chooses the fastest router.
911 */
912 override = time_after(jiffies, n->updated + n->parms->locktime);
913
914 /* Broadcast replies and request packets
915 do not assert neighbour reachability.
916 */
917 if (arp->ar_op != htons(ARPOP_REPLY) ||
918 skb->pkt_type != PACKET_HOST)
919 state = NUD_STALE;
Changli Gaodeffd772010-09-02 03:56:51 +0000920 neigh_update(n, sha, state,
921 override ? NEIGH_UPDATE_F_OVERRIDE : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 neigh_release(n);
923 }
924
925out:
Neil Hormanead2ceb2009-03-11 09:49:55 +0000926 consume_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 return 0;
928}
929
Herbert Xu444fc8f2005-10-03 14:18:10 -0700930static void parp_redo(struct sk_buff *skb)
931{
932 arp_process(skb);
933}
934
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935
936/*
937 * Receive an arp request from the device layer.
938 */
939
Adrian Bunk6c97e722006-04-12 13:57:59 -0700940static int arp_rcv(struct sk_buff *skb, struct net_device *dev,
941 struct packet_type *pt, struct net_device *orig_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942{
943 struct arphdr *arp;
944
945 /* ARP header, plus 2 device addresses, plus 2 IP addresses. */
Pavel Emelyanov988b7052008-03-03 12:20:57 -0800946 if (!pskb_may_pull(skb, arp_hdr_len(dev)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 goto freeskb;
948
Arnaldo Carvalho de Melod0a92be2007-03-12 20:56:31 -0300949 arp = arp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 if (arp->ar_hln != dev->addr_len ||
951 dev->flags & IFF_NOARP ||
952 skb->pkt_type == PACKET_OTHERHOST ||
953 skb->pkt_type == PACKET_LOOPBACK ||
954 arp->ar_pln != 4)
955 goto freeskb;
956
Changli Gaodeffd772010-09-02 03:56:51 +0000957 skb = skb_share_check(skb, GFP_ATOMIC);
958 if (skb == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 goto out_of_mem;
960
Patrick McHardya61bbcf2005-08-14 17:24:31 -0700961 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
962
Jan Engelhardtfdc93142008-10-20 03:34:51 -0700963 return NF_HOOK(NFPROTO_ARP, NF_ARP_IN, skb, dev, NULL, arp_process);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964
965freeskb:
966 kfree_skb(skb);
967out_of_mem:
968 return 0;
969}
970
971/*
972 * User level interface (ioctl)
973 */
974
975/*
976 * Set (create) an ARP cache entry.
977 */
978
Pavel Emelyanov32e569b2007-12-16 13:30:39 -0800979static int arp_req_set_proxy(struct net *net, struct net_device *dev, int on)
Pavel Emelyanovf8b33fd2007-12-05 21:20:50 -0800980{
981 if (dev == NULL) {
Pavel Emelyanov586f1212007-12-16 13:32:48 -0800982 IPV4_DEVCONF_ALL(net, PROXY_ARP) = on;
Pavel Emelyanovf8b33fd2007-12-05 21:20:50 -0800983 return 0;
984 }
Eric Dumazetc5066532011-01-24 13:16:16 -0800985 if (__in_dev_get_rtnl(dev)) {
986 IN_DEV_CONF_SET(__in_dev_get_rtnl(dev), PROXY_ARP, on);
Pavel Emelyanovf8b33fd2007-12-05 21:20:50 -0800987 return 0;
988 }
989 return -ENXIO;
990}
991
Pavel Emelyanov32e569b2007-12-16 13:30:39 -0800992static int arp_req_set_public(struct net *net, struct arpreq *r,
993 struct net_device *dev)
Pavel Emelyanov43dc1702007-12-05 21:19:44 -0800994{
995 __be32 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
996 __be32 mask = ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr;
997
998 if (mask && mask != htonl(0xFFFFFFFF))
999 return -EINVAL;
1000 if (!dev && (r->arp_flags & ATF_COM)) {
Eric Dumazet941666c2010-12-05 01:23:53 +00001001 dev = dev_getbyhwaddr_rcu(net, r->arp_ha.sa_family,
Changli Gaodeffd772010-09-02 03:56:51 +00001002 r->arp_ha.sa_data);
Pavel Emelyanov43dc1702007-12-05 21:19:44 -08001003 if (!dev)
1004 return -ENODEV;
1005 }
1006 if (mask) {
Denis V. Lunev2db82b52008-01-14 22:58:55 -08001007 if (pneigh_lookup(&arp_tbl, net, &ip, dev, 1) == NULL)
Pavel Emelyanov43dc1702007-12-05 21:19:44 -08001008 return -ENOBUFS;
1009 return 0;
1010 }
Pavel Emelyanovf8b33fd2007-12-05 21:20:50 -08001011
Pavel Emelyanov32e569b2007-12-16 13:30:39 -08001012 return arp_req_set_proxy(net, dev, 1);
Pavel Emelyanov43dc1702007-12-05 21:19:44 -08001013}
1014
Pavel Emelyanov32e569b2007-12-16 13:30:39 -08001015static int arp_req_set(struct net *net, struct arpreq *r,
Changli Gaodeffd772010-09-02 03:56:51 +00001016 struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017{
Pavel Emelyanov43dc1702007-12-05 21:19:44 -08001018 __be32 ip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 struct neighbour *neigh;
1020 int err;
1021
Pavel Emelyanov43dc1702007-12-05 21:19:44 -08001022 if (r->arp_flags & ATF_PUBL)
Pavel Emelyanov32e569b2007-12-16 13:30:39 -08001023 return arp_req_set_public(net, r, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024
Pavel Emelyanov43dc1702007-12-05 21:19:44 -08001025 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 if (r->arp_flags & ATF_PERM)
1027 r->arp_flags |= ATF_COM;
1028 if (dev == NULL) {
David S. Miller78fbfd82011-03-12 00:00:52 -05001029 struct rtable *rt = ip_route_output(net, ip, 0, RTO_ONLINK, 0);
David S. Millerb23dd4f2011-03-02 14:31:35 -08001030
1031 if (IS_ERR(rt))
1032 return PTR_ERR(rt);
Changli Gaod8d1f302010-06-10 23:31:35 -07001033 dev = rt->dst.dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 ip_rt_put(rt);
1035 if (!dev)
1036 return -EINVAL;
1037 }
1038 switch (dev->type) {
Igor Maravic40e47832011-12-05 02:25:57 +00001039#if IS_ENABLED(CONFIG_FDDI)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 case ARPHRD_FDDI:
1041 /*
1042 * According to RFC 1390, FDDI devices should accept ARP
1043 * hardware types of 1 (Ethernet). However, to be more
1044 * robust, we'll accept hardware types of either 1 (Ethernet)
1045 * or 6 (IEEE 802.2).
1046 */
1047 if (r->arp_ha.sa_family != ARPHRD_FDDI &&
1048 r->arp_ha.sa_family != ARPHRD_ETHER &&
1049 r->arp_ha.sa_family != ARPHRD_IEEE802)
1050 return -EINVAL;
1051 break;
1052#endif
1053 default:
1054 if (r->arp_ha.sa_family != dev->type)
1055 return -EINVAL;
1056 break;
1057 }
1058
1059 neigh = __neigh_lookup_errno(&arp_tbl, &ip, dev);
1060 err = PTR_ERR(neigh);
1061 if (!IS_ERR(neigh)) {
1062 unsigned state = NUD_STALE;
1063 if (r->arp_flags & ATF_PERM)
1064 state = NUD_PERMANENT;
Changli Gaodeffd772010-09-02 03:56:51 +00001065 err = neigh_update(neigh, (r->arp_flags & ATF_COM) ?
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001066 r->arp_ha.sa_data : NULL, state,
Changli Gaodeffd772010-09-02 03:56:51 +00001067 NEIGH_UPDATE_F_OVERRIDE |
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 NEIGH_UPDATE_F_ADMIN);
1069 neigh_release(neigh);
1070 }
1071 return err;
1072}
1073
1074static unsigned arp_state_to_flags(struct neighbour *neigh)
1075{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 if (neigh->nud_state&NUD_PERMANENT)
Changli Gaodeffd772010-09-02 03:56:51 +00001077 return ATF_PERM | ATF_COM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 else if (neigh->nud_state&NUD_VALID)
Changli Gaodeffd772010-09-02 03:56:51 +00001079 return ATF_COM;
1080 else
1081 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082}
1083
1084/*
1085 * Get an ARP cache entry.
1086 */
1087
1088static int arp_req_get(struct arpreq *r, struct net_device *dev)
1089{
Al Viroed9bad02006-09-27 18:36:36 -07001090 __be32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 struct neighbour *neigh;
1092 int err = -ENXIO;
1093
1094 neigh = neigh_lookup(&arp_tbl, &ip, dev);
1095 if (neigh) {
1096 read_lock_bh(&neigh->lock);
1097 memcpy(r->arp_ha.sa_data, neigh->ha, dev->addr_len);
1098 r->arp_flags = arp_state_to_flags(neigh);
1099 read_unlock_bh(&neigh->lock);
1100 r->arp_ha.sa_family = dev->type;
1101 strlcpy(r->arp_dev, dev->name, sizeof(r->arp_dev));
1102 neigh_release(neigh);
1103 err = 0;
1104 }
1105 return err;
1106}
1107
Maxim Levitsky545ecdc2011-01-08 13:57:12 +00001108int arp_invalidate(struct net_device *dev, __be32 ip)
1109{
1110 struct neighbour *neigh = neigh_lookup(&arp_tbl, &ip, dev);
1111 int err = -ENXIO;
1112
1113 if (neigh) {
1114 if (neigh->nud_state & ~NUD_NOARP)
1115 err = neigh_update(neigh, NULL, NUD_FAILED,
1116 NEIGH_UPDATE_F_OVERRIDE|
1117 NEIGH_UPDATE_F_ADMIN);
1118 neigh_release(neigh);
1119 }
1120
1121 return err;
1122}
1123EXPORT_SYMBOL(arp_invalidate);
1124
Pavel Emelyanov32e569b2007-12-16 13:30:39 -08001125static int arp_req_delete_public(struct net *net, struct arpreq *r,
1126 struct net_device *dev)
Pavel Emelyanov46479b42007-12-05 21:20:18 -08001127{
1128 __be32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
1129 __be32 mask = ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr;
1130
1131 if (mask == htonl(0xFFFFFFFF))
Denis V. Lunev2db82b52008-01-14 22:58:55 -08001132 return pneigh_delete(&arp_tbl, net, &ip, dev);
Pavel Emelyanov46479b42007-12-05 21:20:18 -08001133
Pavel Emelyanovf8b33fd2007-12-05 21:20:50 -08001134 if (mask)
1135 return -EINVAL;
1136
Pavel Emelyanov32e569b2007-12-16 13:30:39 -08001137 return arp_req_set_proxy(net, dev, 0);
Pavel Emelyanov46479b42007-12-05 21:20:18 -08001138}
1139
Pavel Emelyanov32e569b2007-12-16 13:30:39 -08001140static int arp_req_delete(struct net *net, struct arpreq *r,
Changli Gaodeffd772010-09-02 03:56:51 +00001141 struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142{
Pavel Emelyanov46479b42007-12-05 21:20:18 -08001143 __be32 ip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144
Pavel Emelyanov46479b42007-12-05 21:20:18 -08001145 if (r->arp_flags & ATF_PUBL)
Pavel Emelyanov32e569b2007-12-16 13:30:39 -08001146 return arp_req_delete_public(net, r, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147
Pavel Emelyanov46479b42007-12-05 21:20:18 -08001148 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149 if (dev == NULL) {
David S. Miller78fbfd82011-03-12 00:00:52 -05001150 struct rtable *rt = ip_route_output(net, ip, 0, RTO_ONLINK, 0);
David S. Millerb23dd4f2011-03-02 14:31:35 -08001151 if (IS_ERR(rt))
1152 return PTR_ERR(rt);
Changli Gaod8d1f302010-06-10 23:31:35 -07001153 dev = rt->dst.dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 ip_rt_put(rt);
1155 if (!dev)
1156 return -EINVAL;
1157 }
Maxim Levitsky545ecdc2011-01-08 13:57:12 +00001158 return arp_invalidate(dev, ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159}
1160
1161/*
1162 * Handle an ARP layer I/O control request.
1163 */
1164
Pavel Emelyanov32e569b2007-12-16 13:30:39 -08001165int arp_ioctl(struct net *net, unsigned int cmd, void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166{
1167 int err;
1168 struct arpreq r;
1169 struct net_device *dev = NULL;
1170
1171 switch (cmd) {
Changli Gaodeffd772010-09-02 03:56:51 +00001172 case SIOCDARP:
1173 case SIOCSARP:
1174 if (!capable(CAP_NET_ADMIN))
1175 return -EPERM;
1176 case SIOCGARP:
1177 err = copy_from_user(&r, arg, sizeof(struct arpreq));
1178 if (err)
1179 return -EFAULT;
1180 break;
1181 default:
1182 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 }
1184
1185 if (r.arp_pa.sa_family != AF_INET)
1186 return -EPFNOSUPPORT;
1187
1188 if (!(r.arp_flags & ATF_PUBL) &&
Changli Gaodeffd772010-09-02 03:56:51 +00001189 (r.arp_flags & (ATF_NETMASK | ATF_DONTPUB)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 return -EINVAL;
1191 if (!(r.arp_flags & ATF_NETMASK))
1192 ((struct sockaddr_in *)&r.arp_netmask)->sin_addr.s_addr =
1193 htonl(0xFFFFFFFFUL);
Eric Dumazetc5066532011-01-24 13:16:16 -08001194 rtnl_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 if (r.arp_dev[0]) {
1196 err = -ENODEV;
Eric Dumazetc5066532011-01-24 13:16:16 -08001197 dev = __dev_get_by_name(net, r.arp_dev);
Changli Gaodeffd772010-09-02 03:56:51 +00001198 if (dev == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 goto out;
1200
1201 /* Mmmm... It is wrong... ARPHRD_NETROM==0 */
1202 if (!r.arp_ha.sa_family)
1203 r.arp_ha.sa_family = dev->type;
1204 err = -EINVAL;
1205 if ((r.arp_flags & ATF_COM) && r.arp_ha.sa_family != dev->type)
1206 goto out;
1207 } else if (cmd == SIOCGARP) {
1208 err = -ENODEV;
1209 goto out;
1210 }
1211
Stephen Hemminger132adf52007-03-08 20:44:43 -08001212 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213 case SIOCDARP:
Pavel Emelyanov32e569b2007-12-16 13:30:39 -08001214 err = arp_req_delete(net, &r, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 break;
1216 case SIOCSARP:
Pavel Emelyanov32e569b2007-12-16 13:30:39 -08001217 err = arp_req_set(net, &r, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218 break;
1219 case SIOCGARP:
1220 err = arp_req_get(&r, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 break;
1222 }
1223out:
Eric Dumazetc5066532011-01-24 13:16:16 -08001224 rtnl_unlock();
Eric Dumazet941666c2010-12-05 01:23:53 +00001225 if (cmd == SIOCGARP && !err && copy_to_user(arg, &r, sizeof(r)))
1226 err = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 return err;
1228}
1229
Changli Gaodeffd772010-09-02 03:56:51 +00001230static int arp_netdev_event(struct notifier_block *this, unsigned long event,
1231 void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232{
1233 struct net_device *dev = ptr;
1234
1235 switch (event) {
1236 case NETDEV_CHANGEADDR:
1237 neigh_changeaddr(&arp_tbl, dev);
Denis V. Lunev76e6ebf2008-07-05 19:00:44 -07001238 rt_cache_flush(dev_net(dev), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 break;
1240 default:
1241 break;
1242 }
1243
1244 return NOTIFY_DONE;
1245}
1246
1247static struct notifier_block arp_netdev_notifier = {
1248 .notifier_call = arp_netdev_event,
1249};
1250
1251/* Note, that it is not on notifier chain.
1252 It is necessary, that this routine was called after route cache will be
1253 flushed.
1254 */
1255void arp_ifdown(struct net_device *dev)
1256{
1257 neigh_ifdown(&arp_tbl, dev);
1258}
1259
1260
1261/*
1262 * Called once on startup.
1263 */
1264
Stephen Hemminger7546dd92009-03-09 08:18:29 +00001265static struct packet_type arp_packet_type __read_mostly = {
Harvey Harrison09640e62009-02-01 00:45:17 -08001266 .type = cpu_to_be16(ETH_P_ARP),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 .func = arp_rcv,
1268};
1269
1270static int arp_proc_init(void);
1271
1272void __init arp_init(void)
1273{
1274 neigh_table_init(&arp_tbl);
1275
1276 dev_add_pack(&arp_packet_type);
1277 arp_proc_init();
1278#ifdef CONFIG_SYSCTL
Eric W. Biederman54716e32010-02-14 03:27:03 +00001279 neigh_sysctl_register(NULL, &arp_tbl.parms, "ipv4", NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280#endif
1281 register_netdevice_notifier(&arp_netdev_notifier);
1282}
1283
1284#ifdef CONFIG_PROC_FS
Igor Maravic40e47832011-12-05 02:25:57 +00001285#if IS_ENABLED(CONFIG_AX25)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286
1287/* ------------------------------------------------------------------------ */
1288/*
1289 * ax25 -> ASCII conversion
1290 */
1291static char *ax2asc2(ax25_address *a, char *buf)
1292{
1293 char c, *s;
1294 int n;
1295
1296 for (n = 0, s = buf; n < 6; n++) {
1297 c = (a->ax25_call[n] >> 1) & 0x7F;
1298
Changli Gaodeffd772010-09-02 03:56:51 +00001299 if (c != ' ')
1300 *s++ = c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001302
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 *s++ = '-';
Changli Gaodeffd772010-09-02 03:56:51 +00001304 n = (a->ax25_call[6] >> 1) & 0x0F;
1305 if (n > 9) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 *s++ = '1';
1307 n -= 10;
1308 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001309
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 *s++ = n + '0';
1311 *s++ = '\0';
1312
1313 if (*buf == '\0' || *buf == '-')
Changli Gaodeffd772010-09-02 03:56:51 +00001314 return "*";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315
1316 return buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317}
1318#endif /* CONFIG_AX25 */
1319
1320#define HBUFFERLEN 30
1321
1322static void arp_format_neigh_entry(struct seq_file *seq,
1323 struct neighbour *n)
1324{
1325 char hbuffer[HBUFFERLEN];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 int k, j;
1327 char tbuf[16];
1328 struct net_device *dev = n->dev;
1329 int hatype = dev->type;
1330
1331 read_lock(&n->lock);
1332 /* Convert hardware address to XX:XX:XX:XX ... form. */
Igor Maravic40e47832011-12-05 02:25:57 +00001333#if IS_ENABLED(CONFIG_AX25)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 if (hatype == ARPHRD_AX25 || hatype == ARPHRD_NETROM)
1335 ax2asc2((ax25_address *)n->ha, hbuffer);
1336 else {
1337#endif
1338 for (k = 0, j = 0; k < HBUFFERLEN - 3 && j < dev->addr_len; j++) {
Denis Cheng51f82a22008-05-21 17:34:32 -07001339 hbuffer[k++] = hex_asc_hi(n->ha[j]);
1340 hbuffer[k++] = hex_asc_lo(n->ha[j]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 hbuffer[k++] = ':';
1342 }
roel kluina3e8ee62009-07-29 23:46:59 +00001343 if (k != 0)
1344 --k;
1345 hbuffer[k] = 0;
Igor Maravic40e47832011-12-05 02:25:57 +00001346#if IS_ENABLED(CONFIG_AX25)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 }
1348#endif
Harvey Harrison673d57e2008-10-31 00:53:57 -07001349 sprintf(tbuf, "%pI4", n->primary_key);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 seq_printf(seq, "%-16s 0x%-10x0x%-10x%s * %s\n",
1351 tbuf, hatype, arp_state_to_flags(n), hbuffer, dev->name);
1352 read_unlock(&n->lock);
1353}
1354
1355static void arp_format_pneigh_entry(struct seq_file *seq,
1356 struct pneigh_entry *n)
1357{
1358 struct net_device *dev = n->dev;
1359 int hatype = dev ? dev->type : 0;
1360 char tbuf[16];
1361
Harvey Harrison673d57e2008-10-31 00:53:57 -07001362 sprintf(tbuf, "%pI4", n->key);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 seq_printf(seq, "%-16s 0x%-10x0x%-10x%s * %s\n",
1364 tbuf, hatype, ATF_PUBL | ATF_PERM, "00:00:00:00:00:00",
1365 dev ? dev->name : "*");
1366}
1367
1368static int arp_seq_show(struct seq_file *seq, void *v)
1369{
1370 if (v == SEQ_START_TOKEN) {
1371 seq_puts(seq, "IP address HW type Flags "
1372 "HW address Mask Device\n");
1373 } else {
1374 struct neigh_seq_state *state = seq->private;
1375
1376 if (state->flags & NEIGH_SEQ_IS_PNEIGH)
1377 arp_format_pneigh_entry(seq, v);
1378 else
1379 arp_format_neigh_entry(seq, v);
1380 }
1381
1382 return 0;
1383}
1384
1385static void *arp_seq_start(struct seq_file *seq, loff_t *pos)
1386{
1387 /* Don't want to confuse "arp -a" w/ magic entries,
1388 * so we tell the generic iterator to skip NUD_NOARP.
1389 */
1390 return neigh_seq_start(seq, pos, &arp_tbl, NEIGH_SEQ_SKIP_NOARP);
1391}
1392
1393/* ------------------------------------------------------------------------ */
1394
Stephen Hemmingerf6908082007-03-12 14:34:29 -07001395static const struct seq_operations arp_seq_ops = {
Changli Gaodeffd772010-09-02 03:56:51 +00001396 .start = arp_seq_start,
1397 .next = neigh_seq_next,
1398 .stop = neigh_seq_stop,
1399 .show = arp_seq_show,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400};
1401
1402static int arp_seq_open(struct inode *inode, struct file *file)
1403{
Eric W. Biederman426b5302008-01-24 00:13:18 -08001404 return seq_open_net(inode, file, &arp_seq_ops,
1405 sizeof(struct neigh_seq_state));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406}
1407
Arjan van de Ven9a321442007-02-12 00:55:35 -08001408static const struct file_operations arp_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 .owner = THIS_MODULE,
1410 .open = arp_seq_open,
1411 .read = seq_read,
1412 .llseek = seq_lseek,
Eric W. Biederman426b5302008-01-24 00:13:18 -08001413 .release = seq_release_net,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414};
1415
Denis V. Lunevffc31d32008-03-24 15:28:43 -07001416
1417static int __net_init arp_net_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418{
Denis V. Lunevffc31d32008-03-24 15:28:43 -07001419 if (!proc_net_fops_create(net, "arp", S_IRUGO, &arp_seq_fops))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 return -ENOMEM;
1421 return 0;
1422}
1423
Denis V. Lunevffc31d32008-03-24 15:28:43 -07001424static void __net_exit arp_net_exit(struct net *net)
1425{
1426 proc_net_remove(net, "arp");
1427}
1428
1429static struct pernet_operations arp_net_ops = {
1430 .init = arp_net_init,
1431 .exit = arp_net_exit,
1432};
1433
1434static int __init arp_proc_init(void)
1435{
1436 return register_pernet_subsys(&arp_net_ops);
1437}
1438
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439#else /* CONFIG_PROC_FS */
1440
1441static int __init arp_proc_init(void)
1442{
1443 return 0;
1444}
1445
1446#endif /* CONFIG_PROC_FS */