blob: 59402be133f0b4cced6dac7d22fea61fcf89dda6 [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
116#include <asm/system.h>
Changli Gaodeffd772010-09-02 03:56:51 +0000117#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118
119#include <linux/netfilter_arp.h>
120
121/*
122 * Interface to generic neighbour cache.
123 */
David S. Miller2c2aba62011-12-28 15:06:58 -0500124static u32 arp_hash(const void *pkey, const struct net_device *dev, __u32 *hash_rnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125static int arp_constructor(struct neighbour *neigh);
126static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb);
127static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb);
128static void parp_redo(struct sk_buff *skb);
129
Stephen Hemminger89d69d22009-09-01 11:13:19 +0000130static const struct neigh_ops arp_generic_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 .family = AF_INET,
132 .solicit = arp_solicit,
133 .error_report = arp_error_report,
134 .output = neigh_resolve_output,
135 .connected_output = neigh_connected_output,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136};
137
Stephen Hemminger89d69d22009-09-01 11:13:19 +0000138static const struct neigh_ops arp_hh_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 .family = AF_INET,
140 .solicit = arp_solicit,
141 .error_report = arp_error_report,
142 .output = neigh_resolve_output,
143 .connected_output = neigh_resolve_output,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144};
145
Stephen Hemminger89d69d22009-09-01 11:13:19 +0000146static const struct neigh_ops arp_direct_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 .family = AF_INET,
David S. Miller8f40b162011-07-17 13:34:11 -0700148 .output = neigh_direct_output,
149 .connected_output = neigh_direct_output,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150};
151
stephen hemmingera64de472010-09-28 17:08:02 +0000152static const struct neigh_ops arp_broken_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 .family = AF_INET,
154 .solicit = arp_solicit,
155 .error_report = arp_error_report,
156 .output = neigh_compat_output,
157 .connected_output = neigh_compat_output,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158};
159
160struct neigh_table arp_tbl = {
Changli Gaodeffd772010-09-02 03:56:51 +0000161 .family = AF_INET,
Changli Gaodeffd772010-09-02 03:56:51 +0000162 .key_len = 4,
163 .hash = arp_hash,
164 .constructor = arp_constructor,
165 .proxy_redo = parp_redo,
166 .id = "arp_cache",
167 .parms = {
168 .tbl = &arp_tbl,
169 .base_reachable_time = 30 * HZ,
170 .retrans_time = 1 * HZ,
171 .gc_staletime = 60 * HZ,
172 .reachable_time = 30 * HZ,
173 .delay_probe_time = 5 * HZ,
Eric Dumazet8b5c1712011-11-09 12:07:14 +0000174 .queue_len_bytes = 64*1024,
Changli Gaodeffd772010-09-02 03:56:51 +0000175 .ucast_probes = 3,
176 .mcast_probes = 3,
177 .anycast_delay = 1 * HZ,
178 .proxy_delay = (8 * HZ) / 10,
179 .proxy_qlen = 64,
180 .locktime = 1 * HZ,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 },
Changli Gaodeffd772010-09-02 03:56:51 +0000182 .gc_interval = 30 * HZ,
183 .gc_thresh1 = 128,
184 .gc_thresh2 = 512,
185 .gc_thresh3 = 1024,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186};
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000187EXPORT_SYMBOL(arp_tbl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188
Al Viro714e85b2006-11-14 20:51:49 -0800189int arp_mc_map(__be32 addr, u8 *haddr, struct net_device *dev, int dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190{
191 switch (dev->type) {
192 case ARPHRD_ETHER:
193 case ARPHRD_FDDI:
194 case ARPHRD_IEEE802:
195 ip_eth_mc_map(addr, haddr);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900196 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 case ARPHRD_IEEE802_TR:
198 ip_tr_mc_map(addr, haddr);
199 return 0;
200 case ARPHRD_INFINIBAND:
Rolf Manderscheida9e527e2007-12-10 13:38:41 -0700201 ip_ib_mc_map(addr, dev->broadcast, haddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 return 0;
Timo Teräs93ca3bb2011-03-28 22:40:53 +0000203 case ARPHRD_IPGRE:
204 ip_ipgre_mc_map(addr, dev->broadcast, haddr);
205 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 default:
207 if (dir) {
208 memcpy(haddr, dev->broadcast, dev->addr_len);
209 return 0;
210 }
211 }
212 return -EINVAL;
213}
214
215
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000216static u32 arp_hash(const void *pkey,
217 const struct net_device *dev,
David S. Miller2c2aba62011-12-28 15:06:58 -0500218 __u32 *hash_rnd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219{
David S. Miller2c2aba62011-12-28 15:06:58 -0500220 return arp_hashfn(*(u32 *)pkey, dev, *hash_rnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221}
222
223static int arp_constructor(struct neighbour *neigh)
224{
Changli Gaodeffd772010-09-02 03:56:51 +0000225 __be32 addr = *(__be32 *)neigh->primary_key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 struct net_device *dev = neigh->dev;
227 struct in_device *in_dev;
228 struct neigh_parms *parms;
229
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 rcu_read_lock();
Herbert Xue5ed6392005-10-03 14:35:55 -0700231 in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 if (in_dev == NULL) {
233 rcu_read_unlock();
234 return -EINVAL;
235 }
236
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900237 neigh->type = inet_addr_type(dev_net(dev), addr);
Denis V. Luneva79878f2008-01-14 22:56:01 -0800238
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 parms = in_dev->arp_parms;
240 __neigh_parms_put(neigh->parms);
241 neigh->parms = neigh_parms_clone(parms);
242 rcu_read_unlock();
243
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700244 if (!dev->header_ops) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 neigh->nud_state = NUD_NOARP;
246 neigh->ops = &arp_direct_ops;
David S. Miller8f40b162011-07-17 13:34:11 -0700247 neigh->output = neigh_direct_output;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 } else {
249 /* Good devices (checked by reading texts, but only Ethernet is
250 tested)
251
252 ARPHRD_ETHER: (ethernet, apfddi)
253 ARPHRD_FDDI: (fddi)
254 ARPHRD_IEEE802: (tr)
255 ARPHRD_METRICOM: (strip)
256 ARPHRD_ARCNET:
257 etc. etc. etc.
258
259 ARPHRD_IPDDP will also work, if author repairs it.
260 I did not it, because this driver does not work even
261 in old paradigm.
262 */
263
264#if 1
265 /* So... these "amateur" devices are hopeless.
266 The only thing, that I can say now:
267 It is very sad that we need to keep ugly obsolete
268 code to make them happy.
269
270 They should be moved to more reasonable state, now
271 they use rebuild_header INSTEAD OF hard_start_xmit!!!
272 Besides that, they are sort of out of date
273 (a lot of redundant clones/copies, useless in 2.1),
274 I wonder why people believe that they work.
275 */
276 switch (dev->type) {
277 default:
278 break;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900279 case ARPHRD_ROSE:
Igor Maravic40e47832011-12-05 02:25:57 +0000280#if IS_ENABLED(CONFIG_AX25)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 case ARPHRD_AX25:
Igor Maravic40e47832011-12-05 02:25:57 +0000282#if IS_ENABLED(CONFIG_NETROM)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 case ARPHRD_NETROM:
284#endif
285 neigh->ops = &arp_broken_ops;
286 neigh->output = neigh->ops->output;
287 return 0;
Changli Gaodeffd772010-09-02 03:56:51 +0000288#else
289 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290#endif
Changli Gaodeffd772010-09-02 03:56:51 +0000291 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292#endif
293 if (neigh->type == RTN_MULTICAST) {
294 neigh->nud_state = NUD_NOARP;
295 arp_mc_map(addr, neigh->ha, dev, 1);
Changli Gaodeffd772010-09-02 03:56:51 +0000296 } else if (dev->flags & (IFF_NOARP | IFF_LOOPBACK)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 neigh->nud_state = NUD_NOARP;
298 memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
Changli Gaodeffd772010-09-02 03:56:51 +0000299 } else if (neigh->type == RTN_BROADCAST ||
300 (dev->flags & IFF_POINTOPOINT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 neigh->nud_state = NUD_NOARP;
302 memcpy(neigh->ha, dev->broadcast, dev->addr_len);
303 }
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700304
305 if (dev->header_ops->cache)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 neigh->ops = &arp_hh_ops;
307 else
308 neigh->ops = &arp_generic_ops;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700309
Changli Gaodeffd772010-09-02 03:56:51 +0000310 if (neigh->nud_state & NUD_VALID)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 neigh->output = neigh->ops->connected_output;
312 else
313 neigh->output = neigh->ops->output;
314 }
315 return 0;
316}
317
318static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb)
319{
320 dst_link_failure(skb);
321 kfree_skb(skb);
322}
323
324static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb)
325{
Al Viroa61ced52006-09-26 21:27:54 -0700326 __be32 saddr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 u8 *dst_ha = NULL;
328 struct net_device *dev = neigh->dev;
Changli Gaodeffd772010-09-02 03:56:51 +0000329 __be32 target = *(__be32 *)neigh->primary_key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 int probes = atomic_read(&neigh->probes);
Eric Dumazet4b4194c2010-06-22 07:43:15 +0000331 struct in_device *in_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332
Eric Dumazet4b4194c2010-06-22 07:43:15 +0000333 rcu_read_lock();
334 in_dev = __in_dev_get_rcu(dev);
335 if (!in_dev) {
336 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 return;
Eric Dumazet4b4194c2010-06-22 07:43:15 +0000338 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 switch (IN_DEV_ARP_ANNOUNCE(in_dev)) {
340 default:
341 case 0: /* By default announce any local IP */
Changli Gaodeffd772010-09-02 03:56:51 +0000342 if (skb && inet_addr_type(dev_net(dev),
343 ip_hdr(skb)->saddr) == RTN_LOCAL)
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700344 saddr = ip_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 break;
346 case 1: /* Restrict announcements of saddr in same subnet */
347 if (!skb)
348 break;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700349 saddr = ip_hdr(skb)->saddr;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900350 if (inet_addr_type(dev_net(dev), saddr) == RTN_LOCAL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 /* saddr should be known to target */
352 if (inet_addr_onlink(in_dev, target, saddr))
353 break;
354 }
355 saddr = 0;
356 break;
357 case 2: /* Avoid secondary IPs, get a primary/preferred one */
358 break;
359 }
Eric Dumazet4b4194c2010-06-22 07:43:15 +0000360 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 if (!saddr)
363 saddr = inet_select_addr(dev, target, RT_SCOPE_LINK);
364
Changli Gaodeffd772010-09-02 03:56:51 +0000365 probes -= neigh->parms->ucast_probes;
366 if (probes < 0) {
367 if (!(neigh->nud_state & NUD_VALID))
368 printk(KERN_DEBUG
369 "trying to ucast probe in NUD_INVALID\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 dst_ha = neigh->ha;
David S. Miller9ff56602008-02-17 18:39:54 -0800371 read_lock_bh(&neigh->lock);
Changli Gaodeffd772010-09-02 03:56:51 +0000372 } else {
373 probes -= neigh->parms->app_probes;
374 if (probes < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375#ifdef CONFIG_ARPD
Changli Gaodeffd772010-09-02 03:56:51 +0000376 neigh_app_ns(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377#endif
Changli Gaodeffd772010-09-02 03:56:51 +0000378 return;
379 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 }
381
382 arp_send(ARPOP_REQUEST, ETH_P_ARP, target, dev, saddr,
383 dst_ha, dev->dev_addr, NULL);
David S. Miller9ff56602008-02-17 18:39:54 -0800384 if (dst_ha)
385 read_unlock_bh(&neigh->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386}
387
Denis V. Lunev9bd85e32008-01-14 23:05:55 -0800388static int arp_ignore(struct in_device *in_dev, __be32 sip, __be32 tip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389{
390 int scope;
391
392 switch (IN_DEV_ARP_IGNORE(in_dev)) {
393 case 0: /* Reply, the tip is already validated */
394 return 0;
395 case 1: /* Reply only if tip is configured on the incoming interface */
396 sip = 0;
397 scope = RT_SCOPE_HOST;
398 break;
399 case 2: /*
400 * Reply only if tip is configured on the incoming interface
401 * and is in same subnet as sip
402 */
403 scope = RT_SCOPE_HOST;
404 break;
405 case 3: /* Do not reply for scope host addresses */
406 sip = 0;
407 scope = RT_SCOPE_LINK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 break;
409 case 4: /* Reserved */
410 case 5:
411 case 6:
412 case 7:
413 return 0;
414 case 8: /* Do not reply */
415 return 1;
416 default:
417 return 0;
418 }
Denis V. Lunev9bd85e32008-01-14 23:05:55 -0800419 return !inet_confirm_addr(in_dev, sip, tip, scope);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420}
421
Al Viroed9bad02006-09-27 18:36:36 -0700422static int arp_filter(__be32 sip, __be32 tip, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 struct rtable *rt;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900425 int flag = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 /*unsigned long now; */
Pavel Emelyanovca12a1a2008-07-16 20:28:42 -0700427 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428
David S. Miller78fbfd82011-03-12 00:00:52 -0500429 rt = ip_route_output(net, sip, tip, 0, 0);
David S. Millerb23dd4f2011-03-02 14:31:35 -0800430 if (IS_ERR(rt))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 return 1;
Changli Gaod8d1f302010-06-10 23:31:35 -0700432 if (rt->dst.dev != dev) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700433 NET_INC_STATS_BH(net, LINUX_MIB_ARPFILTER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 flag = 1;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900435 }
436 ip_rt_put(rt);
437 return flag;
438}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439
440/* OBSOLETE FUNCTIONS */
441
442/*
443 * Find an arp mapping in the cache. If not found, post a request.
444 *
445 * It is very UGLY routine: it DOES NOT use skb->dst->neighbour,
446 * even if it exists. It is supposed that skb->dev was mangled
447 * by a virtual device (eql, shaper). Nobody but broken devices
448 * is allowed to use this function, it is scheduled to be removed. --ANK
449 */
450
Changli Gaodeffd772010-09-02 03:56:51 +0000451static int arp_set_predefined(int addr_hint, unsigned char *haddr,
452 __be32 paddr, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453{
454 switch (addr_hint) {
455 case RTN_LOCAL:
456 printk(KERN_DEBUG "ARP: arp called for own IP address\n");
457 memcpy(haddr, dev->dev_addr, dev->addr_len);
458 return 1;
459 case RTN_MULTICAST:
460 arp_mc_map(paddr, haddr, dev, 1);
461 return 1;
462 case RTN_BROADCAST:
463 memcpy(haddr, dev->broadcast, dev->addr_len);
464 return 1;
465 }
466 return 0;
467}
468
469
470int arp_find(unsigned char *haddr, struct sk_buff *skb)
471{
472 struct net_device *dev = skb->dev;
Al Virofd683222006-09-26 22:17:51 -0700473 __be32 paddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 struct neighbour *n;
475
Eric Dumazetadf30902009-06-02 05:19:30 +0000476 if (!skb_dst(skb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 printk(KERN_DEBUG "arp_find is called with dst==NULL\n");
478 kfree_skb(skb);
479 return 1;
480 }
481
Eric Dumazet511c3f92009-06-02 05:14:27 +0000482 paddr = skb_rtable(skb)->rt_gateway;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483
Changli Gaodeffd772010-09-02 03:56:51 +0000484 if (arp_set_predefined(inet_addr_type(dev_net(dev), paddr), haddr,
485 paddr, dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 return 0;
487
488 n = __neigh_lookup(&arp_tbl, &paddr, dev, 1);
489
490 if (n) {
491 n->used = jiffies;
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +0000492 if (n->nud_state & NUD_VALID || neigh_event_send(n, skb) == 0) {
493 neigh_ha_snapshot(haddr, n, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 neigh_release(n);
495 return 0;
496 }
497 neigh_release(n);
498 } else
499 kfree_skb(skb);
500 return 1;
501}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000502EXPORT_SYMBOL(arp_find);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
504/* END OF OBSOLETE FUNCTIONS */
505
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506/*
507 * Check if we can use proxy ARP for this path
508 */
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +0000509static inline int arp_fwd_proxy(struct in_device *in_dev,
510 struct net_device *dev, struct rtable *rt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511{
512 struct in_device *out_dev;
513 int imi, omi = -1;
514
Changli Gaod8d1f302010-06-10 23:31:35 -0700515 if (rt->dst.dev == dev)
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +0000516 return 0;
517
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 if (!IN_DEV_PROXY_ARP(in_dev))
519 return 0;
Changli Gaodeffd772010-09-02 03:56:51 +0000520 imi = IN_DEV_MEDIUM_ID(in_dev);
521 if (imi == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 return 1;
523 if (imi == -1)
524 return 0;
525
526 /* place to check for proxy_arp for routes */
527
Changli Gaod8d1f302010-06-10 23:31:35 -0700528 out_dev = __in_dev_get_rcu(rt->dst.dev);
Eric Dumazetfaa9dcf2010-06-03 04:09:10 +0000529 if (out_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 omi = IN_DEV_MEDIUM_ID(out_dev);
Eric Dumazetfaa9dcf2010-06-03 04:09:10 +0000531
Eric Dumazeta02cec22010-09-22 20:43:57 +0000532 return omi != imi && omi != -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533}
534
535/*
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +0000536 * Check for RFC3069 proxy arp private VLAN (allow to send back to same dev)
537 *
538 * RFC3069 supports proxy arp replies back to the same interface. This
539 * is done to support (ethernet) switch features, like RFC 3069, where
540 * the individual ports are not allowed to communicate with each
541 * other, BUT they are allowed to talk to the upstream router. As
542 * described in RFC 3069, it is possible to allow these hosts to
543 * communicate through the upstream router, by proxy_arp'ing.
544 *
545 * RFC 3069: "VLAN Aggregation for Efficient IP Address Allocation"
546 *
547 * This technology is known by different names:
548 * In RFC 3069 it is called VLAN Aggregation.
549 * Cisco and Allied Telesyn call it Private VLAN.
550 * Hewlett-Packard call it Source-Port filtering or port-isolation.
551 * Ericsson call it MAC-Forced Forwarding (RFC Draft).
552 *
553 */
554static inline int arp_fwd_pvlan(struct in_device *in_dev,
555 struct net_device *dev, struct rtable *rt,
556 __be32 sip, __be32 tip)
557{
558 /* Private VLAN is only concerned about the same ethernet segment */
Changli Gaod8d1f302010-06-10 23:31:35 -0700559 if (rt->dst.dev != dev)
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +0000560 return 0;
561
562 /* Don't reply on self probes (often done by windowz boxes)*/
563 if (sip == tip)
564 return 0;
565
566 if (IN_DEV_PROXY_ARP_PVLAN(in_dev))
567 return 1;
568 else
569 return 0;
570}
571
572/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 * Interface to link layer: send routine and receive handler.
574 */
575
576/*
577 * Create an arp packet. If (dest_hw == NULL), we create a broadcast
578 * message.
579 */
Al Viroed9bad02006-09-27 18:36:36 -0700580struct sk_buff *arp_create(int type, int ptype, __be32 dest_ip,
581 struct net_device *dev, __be32 src_ip,
Jan Engelhardtabfdf1c2008-01-31 03:59:24 -0800582 const unsigned char *dest_hw,
583 const unsigned char *src_hw,
584 const unsigned char *target_hw)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585{
586 struct sk_buff *skb;
587 struct arphdr *arp;
588 unsigned char *arp_ptr;
Herbert Xu66088242011-11-18 02:20:04 +0000589 int hlen = LL_RESERVED_SPACE(dev);
590 int tlen = dev->needed_tailroom;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591
592 /*
593 * Allocate a buffer
594 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900595
Herbert Xu66088242011-11-18 02:20:04 +0000596 skb = alloc_skb(arp_hdr_len(dev) + hlen + tlen, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 if (skb == NULL)
598 return NULL;
599
Herbert Xu66088242011-11-18 02:20:04 +0000600 skb_reserve(skb, hlen);
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -0700601 skb_reset_network_header(skb);
Pavel Emelyanov988b7052008-03-03 12:20:57 -0800602 arp = (struct arphdr *) skb_put(skb, arp_hdr_len(dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 skb->dev = dev;
604 skb->protocol = htons(ETH_P_ARP);
605 if (src_hw == NULL)
606 src_hw = dev->dev_addr;
607 if (dest_hw == NULL)
608 dest_hw = dev->broadcast;
609
610 /*
611 * Fill the device header for the ARP frame
612 */
Stephen Hemminger0c4e8582007-10-09 01:36:32 -0700613 if (dev_hard_header(skb, dev, ptype, dest_hw, src_hw, skb->len) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 goto out;
615
616 /*
617 * Fill out the arp protocol part.
618 *
619 * The arp hardware type should match the device type, except for FDDI,
620 * which (according to RFC 1390) should always equal 1 (Ethernet).
621 */
622 /*
623 * Exceptions everywhere. AX.25 uses the AX.25 PID value not the
624 * DIX code for the protocol. Make these device structure fields.
625 */
626 switch (dev->type) {
627 default:
628 arp->ar_hrd = htons(dev->type);
629 arp->ar_pro = htons(ETH_P_IP);
630 break;
631
Igor Maravic40e47832011-12-05 02:25:57 +0000632#if IS_ENABLED(CONFIG_AX25)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 case ARPHRD_AX25:
634 arp->ar_hrd = htons(ARPHRD_AX25);
635 arp->ar_pro = htons(AX25_P_IP);
636 break;
637
Igor Maravic40e47832011-12-05 02:25:57 +0000638#if IS_ENABLED(CONFIG_NETROM)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 case ARPHRD_NETROM:
640 arp->ar_hrd = htons(ARPHRD_NETROM);
641 arp->ar_pro = htons(AX25_P_IP);
642 break;
643#endif
644#endif
645
Igor Maravic40e47832011-12-05 02:25:57 +0000646#if IS_ENABLED(CONFIG_FDDI)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 case ARPHRD_FDDI:
648 arp->ar_hrd = htons(ARPHRD_ETHER);
649 arp->ar_pro = htons(ETH_P_IP);
650 break;
651#endif
Igor Maravic40e47832011-12-05 02:25:57 +0000652#if IS_ENABLED(CONFIG_TR)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 case ARPHRD_IEEE802_TR:
654 arp->ar_hrd = htons(ARPHRD_IEEE802);
655 arp->ar_pro = htons(ETH_P_IP);
656 break;
657#endif
658 }
659
660 arp->ar_hln = dev->addr_len;
661 arp->ar_pln = 4;
662 arp->ar_op = htons(type);
663
Changli Gaodeffd772010-09-02 03:56:51 +0000664 arp_ptr = (unsigned char *)(arp + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665
666 memcpy(arp_ptr, src_hw, dev->addr_len);
Jianjun Kongf4cca7f2008-11-03 02:48:14 -0800667 arp_ptr += dev->addr_len;
668 memcpy(arp_ptr, &src_ip, 4);
669 arp_ptr += 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 if (target_hw != NULL)
671 memcpy(arp_ptr, target_hw, dev->addr_len);
672 else
673 memset(arp_ptr, 0, dev->addr_len);
Jianjun Kongf4cca7f2008-11-03 02:48:14 -0800674 arp_ptr += dev->addr_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 memcpy(arp_ptr, &dest_ip, 4);
676
677 return skb;
678
679out:
680 kfree_skb(skb);
681 return NULL;
682}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000683EXPORT_SYMBOL(arp_create);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684
685/*
686 * Send an arp packet.
687 */
688void arp_xmit(struct sk_buff *skb)
689{
690 /* Send it off, maybe filter it using firewalling first. */
Jan Engelhardtfdc93142008-10-20 03:34:51 -0700691 NF_HOOK(NFPROTO_ARP, NF_ARP_OUT, skb, NULL, skb->dev, dev_queue_xmit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000693EXPORT_SYMBOL(arp_xmit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694
695/*
696 * Create and send an arp packet.
697 */
Al Viroed9bad02006-09-27 18:36:36 -0700698void arp_send(int type, int ptype, __be32 dest_ip,
699 struct net_device *dev, __be32 src_ip,
Jan Engelhardtabfdf1c2008-01-31 03:59:24 -0800700 const unsigned char *dest_hw, const unsigned char *src_hw,
701 const unsigned char *target_hw)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702{
703 struct sk_buff *skb;
704
705 /*
706 * No arp on this interface.
707 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900708
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 if (dev->flags&IFF_NOARP)
710 return;
711
712 skb = arp_create(type, ptype, dest_ip, dev, src_ip,
713 dest_hw, src_hw, target_hw);
Changli Gaodeffd772010-09-02 03:56:51 +0000714 if (skb == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716
717 arp_xmit(skb);
718}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000719EXPORT_SYMBOL(arp_send);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721/*
722 * Process an arp request.
723 */
724
725static int arp_process(struct sk_buff *skb)
726{
727 struct net_device *dev = skb->dev;
Eric Dumazetfaa9dcf2010-06-03 04:09:10 +0000728 struct in_device *in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 struct arphdr *arp;
730 unsigned char *arp_ptr;
731 struct rtable *rt;
Mark Rydene0260fe2007-12-19 23:38:11 -0800732 unsigned char *sha;
Al Viro9e12bb22006-09-26 21:25:20 -0700733 __be32 sip, tip;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 u16 dev_type = dev->type;
735 int addr_type;
736 struct neighbour *n;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900737 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738
739 /* arp_rcv below verifies the ARP header and verifies the device
740 * is ARP'able.
741 */
742
743 if (in_dev == NULL)
744 goto out;
745
Arnaldo Carvalho de Melod0a92be2007-03-12 20:56:31 -0300746 arp = arp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747
748 switch (dev_type) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900749 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 if (arp->ar_pro != htons(ETH_P_IP) ||
751 htons(dev_type) != arp->ar_hrd)
752 goto out;
753 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 case ARPHRD_ETHER:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 case ARPHRD_IEEE802_TR:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 case ARPHRD_FDDI:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 case ARPHRD_IEEE802:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 /*
759 * ETHERNET, Token Ring and Fibre Channel (which are IEEE 802
760 * devices, according to RFC 2625) devices will accept ARP
761 * hardware types of either 1 (Ethernet) or 6 (IEEE 802.2).
762 * This is the case also of FDDI, where the RFC 1390 says that
763 * FDDI devices should accept ARP hardware of (1) Ethernet,
764 * however, to be more robust, we'll accept both 1 (Ethernet)
765 * or 6 (IEEE 802.2)
766 */
767 if ((arp->ar_hrd != htons(ARPHRD_ETHER) &&
768 arp->ar_hrd != htons(ARPHRD_IEEE802)) ||
769 arp->ar_pro != htons(ETH_P_IP))
770 goto out;
771 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 case ARPHRD_AX25:
773 if (arp->ar_pro != htons(AX25_P_IP) ||
774 arp->ar_hrd != htons(ARPHRD_AX25))
775 goto out;
776 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 case ARPHRD_NETROM:
778 if (arp->ar_pro != htons(AX25_P_IP) ||
779 arp->ar_hrd != htons(ARPHRD_NETROM))
780 goto out;
781 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 }
783
784 /* Understand only these message types */
785
786 if (arp->ar_op != htons(ARPOP_REPLY) &&
787 arp->ar_op != htons(ARPOP_REQUEST))
788 goto out;
789
790/*
791 * Extract fields
792 */
Changli Gaodeffd772010-09-02 03:56:51 +0000793 arp_ptr = (unsigned char *)(arp + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 sha = arp_ptr;
795 arp_ptr += dev->addr_len;
796 memcpy(&sip, arp_ptr, 4);
797 arp_ptr += 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 arp_ptr += dev->addr_len;
799 memcpy(&tip, arp_ptr, 4);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900800/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 * Check for bad requests for 127.x.x.x and requests for multicast
802 * addresses. If this is one such, delete it.
803 */
Joe Perchesf97c1e02007-12-16 13:45:43 -0800804 if (ipv4_is_loopback(tip) || ipv4_is_multicast(tip))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 goto out;
806
807/*
808 * Special case: We must set Frame Relay source Q.922 address
809 */
810 if (dev_type == ARPHRD_DLCI)
811 sha = dev->broadcast;
812
813/*
814 * Process entry. The idea here is we want to send a reply if it is a
815 * request for us or if it is a request for someone else that we hold
816 * a proxy for. We want to add an entry to our cache if it is a reply
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900817 * to us or if it is a request for our address.
818 * (The assumption for this last is that if someone is requesting our
819 * address, they are probably intending to talk to us, so it saves time
820 * if we cache their address. Their address is also probably not in
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 * our cache, since ours is not in their cache.)
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900822 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 * Putting this another way, we only care about replies if they are to
824 * us, in which case we add them to the cache. For requests, we care
825 * about those for us and those for our proxies. We reply to both,
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900826 * and in the case of requests for us we add the requester to the arp
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 * cache.
828 */
829
Eric W. Biedermanf8a68e72009-06-30 16:27:17 +0000830 /* Special case: IPv4 duplicate address detection packet (RFC2131) */
831 if (sip == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 if (arp->ar_op == htons(ARPOP_REQUEST) &&
Denis V. Lunev49e8a272008-03-24 15:28:12 -0700833 inet_addr_type(net, tip) == RTN_LOCAL &&
Denis V. Lunev9bd85e32008-01-14 23:05:55 -0800834 !arp_ignore(in_dev, sip, tip))
Jonas Danielssonb4a98112007-11-20 17:38:16 -0800835 arp_send(ARPOP_REPLY, ETH_P_ARP, sip, dev, tip, sha,
836 dev->dev_addr, sha);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 goto out;
838 }
839
840 if (arp->ar_op == htons(ARPOP_REQUEST) &&
Eric Dumazet4a944452010-05-10 11:33:06 +0000841 ip_route_input_noref(skb, tip, sip, 0, dev) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842
Eric Dumazet511c3f92009-06-02 05:14:27 +0000843 rt = skb_rtable(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 addr_type = rt->rt_type;
845
846 if (addr_type == RTN_LOCAL) {
Changli Gaodeffd772010-09-02 03:56:51 +0000847 int dont_send;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848
Changli Gaodeffd772010-09-02 03:56:51 +0000849 dont_send = arp_ignore(in_dev, sip, tip);
Ben Greear8164f1b2008-11-16 19:19:38 -0800850 if (!dont_send && IN_DEV_ARPFILTER(in_dev))
Changli Gaoae9c4162010-12-01 20:07:31 +0000851 dont_send = arp_filter(sip, tip, dev);
Ben Greear8164f1b2008-11-16 19:19:38 -0800852 if (!dont_send) {
853 n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
854 if (n) {
Changli Gaodeffd772010-09-02 03:56:51 +0000855 arp_send(ARPOP_REPLY, ETH_P_ARP, sip,
856 dev, tip, sha, dev->dev_addr,
857 sha);
Ben Greear8164f1b2008-11-16 19:19:38 -0800858 neigh_release(n);
859 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 }
861 goto out;
862 } else if (IN_DEV_FORWARD(in_dev)) {
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +0000863 if (addr_type == RTN_UNICAST &&
864 (arp_fwd_proxy(in_dev, dev, rt) ||
865 arp_fwd_pvlan(in_dev, dev, rt, sip, tip) ||
Changli Gaodeffd772010-09-02 03:56:51 +0000866 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
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900891 if (IPV4_DEVCONF_ALL(dev_net(dev), ARP_ACCEPT)) {
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 */