blob: 7927589813b54b5baa50ae29904c5b0e21f6a513 [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>
100#include <linux/jhash.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +0900101#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102#ifdef CONFIG_SYSCTL
103#include <linux/sysctl.h>
104#endif
105
Eric W. Biederman457c4cb2007-09-12 12:01:34 +0200106#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107#include <net/ip.h>
108#include <net/icmp.h>
109#include <net/route.h>
110#include <net/protocol.h>
111#include <net/tcp.h>
112#include <net/sock.h>
113#include <net/arp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114#include <net/ax25.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115#include <net/netrom.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116#if defined(CONFIG_ATM_CLIP) || defined(CONFIG_ATM_CLIP_MODULE)
117#include <net/atmclip.h>
118struct neigh_table *clip_tbl_hook;
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000119EXPORT_SYMBOL(clip_tbl_hook);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120#endif
121
122#include <asm/system.h>
Changli Gaodeffd772010-09-02 03:56:51 +0000123#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124
125#include <linux/netfilter_arp.h>
126
127/*
128 * Interface to generic neighbour cache.
129 */
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000130static u32 arp_hash(const void *pkey, const struct net_device *dev, __u32 rnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131static int arp_constructor(struct neighbour *neigh);
132static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb);
133static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb);
134static void parp_redo(struct sk_buff *skb);
135
Stephen Hemminger89d69d22009-09-01 11:13:19 +0000136static const struct neigh_ops arp_generic_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 .family = AF_INET,
138 .solicit = arp_solicit,
139 .error_report = arp_error_report,
140 .output = neigh_resolve_output,
141 .connected_output = neigh_connected_output,
142 .hh_output = dev_queue_xmit,
143 .queue_xmit = dev_queue_xmit,
144};
145
Stephen Hemminger89d69d22009-09-01 11:13:19 +0000146static const struct neigh_ops arp_hh_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 .family = AF_INET,
148 .solicit = arp_solicit,
149 .error_report = arp_error_report,
150 .output = neigh_resolve_output,
151 .connected_output = neigh_resolve_output,
152 .hh_output = dev_queue_xmit,
153 .queue_xmit = dev_queue_xmit,
154};
155
Stephen Hemminger89d69d22009-09-01 11:13:19 +0000156static const struct neigh_ops arp_direct_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 .family = AF_INET,
158 .output = dev_queue_xmit,
159 .connected_output = dev_queue_xmit,
160 .hh_output = dev_queue_xmit,
161 .queue_xmit = dev_queue_xmit,
162};
163
stephen hemmingera64de472010-09-28 17:08:02 +0000164static const struct neigh_ops arp_broken_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 .family = AF_INET,
166 .solicit = arp_solicit,
167 .error_report = arp_error_report,
168 .output = neigh_compat_output,
169 .connected_output = neigh_compat_output,
170 .hh_output = dev_queue_xmit,
171 .queue_xmit = dev_queue_xmit,
172};
173
174struct neigh_table arp_tbl = {
Changli Gaodeffd772010-09-02 03:56:51 +0000175 .family = AF_INET,
176 .entry_size = sizeof(struct neighbour) + 4,
177 .key_len = 4,
178 .hash = arp_hash,
179 .constructor = arp_constructor,
180 .proxy_redo = parp_redo,
181 .id = "arp_cache",
182 .parms = {
183 .tbl = &arp_tbl,
184 .base_reachable_time = 30 * HZ,
185 .retrans_time = 1 * HZ,
186 .gc_staletime = 60 * HZ,
187 .reachable_time = 30 * HZ,
188 .delay_probe_time = 5 * HZ,
189 .queue_len = 3,
190 .ucast_probes = 3,
191 .mcast_probes = 3,
192 .anycast_delay = 1 * HZ,
193 .proxy_delay = (8 * HZ) / 10,
194 .proxy_qlen = 64,
195 .locktime = 1 * HZ,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 },
Changli Gaodeffd772010-09-02 03:56:51 +0000197 .gc_interval = 30 * HZ,
198 .gc_thresh1 = 128,
199 .gc_thresh2 = 512,
200 .gc_thresh3 = 1024,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201};
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000202EXPORT_SYMBOL(arp_tbl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203
Al Viro714e85b2006-11-14 20:51:49 -0800204int arp_mc_map(__be32 addr, u8 *haddr, struct net_device *dev, int dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205{
206 switch (dev->type) {
207 case ARPHRD_ETHER:
208 case ARPHRD_FDDI:
209 case ARPHRD_IEEE802:
210 ip_eth_mc_map(addr, haddr);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900211 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 case ARPHRD_IEEE802_TR:
213 ip_tr_mc_map(addr, haddr);
214 return 0;
215 case ARPHRD_INFINIBAND:
Rolf Manderscheida9e527e2007-12-10 13:38:41 -0700216 ip_ib_mc_map(addr, dev->broadcast, haddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 return 0;
218 default:
219 if (dir) {
220 memcpy(haddr, dev->broadcast, dev->addr_len);
221 return 0;
222 }
223 }
224 return -EINVAL;
225}
226
227
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000228static u32 arp_hash(const void *pkey,
229 const struct net_device *dev,
230 __u32 hash_rnd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231{
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000232 return jhash_2words(*(u32 *)pkey, dev->ifindex, hash_rnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233}
234
235static int arp_constructor(struct neighbour *neigh)
236{
Changli Gaodeffd772010-09-02 03:56:51 +0000237 __be32 addr = *(__be32 *)neigh->primary_key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 struct net_device *dev = neigh->dev;
239 struct in_device *in_dev;
240 struct neigh_parms *parms;
241
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 rcu_read_lock();
Herbert Xue5ed6392005-10-03 14:35:55 -0700243 in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 if (in_dev == NULL) {
245 rcu_read_unlock();
246 return -EINVAL;
247 }
248
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900249 neigh->type = inet_addr_type(dev_net(dev), addr);
Denis V. Luneva79878f2008-01-14 22:56:01 -0800250
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 parms = in_dev->arp_parms;
252 __neigh_parms_put(neigh->parms);
253 neigh->parms = neigh_parms_clone(parms);
254 rcu_read_unlock();
255
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700256 if (!dev->header_ops) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 neigh->nud_state = NUD_NOARP;
258 neigh->ops = &arp_direct_ops;
259 neigh->output = neigh->ops->queue_xmit;
260 } else {
261 /* Good devices (checked by reading texts, but only Ethernet is
262 tested)
263
264 ARPHRD_ETHER: (ethernet, apfddi)
265 ARPHRD_FDDI: (fddi)
266 ARPHRD_IEEE802: (tr)
267 ARPHRD_METRICOM: (strip)
268 ARPHRD_ARCNET:
269 etc. etc. etc.
270
271 ARPHRD_IPDDP will also work, if author repairs it.
272 I did not it, because this driver does not work even
273 in old paradigm.
274 */
275
276#if 1
277 /* So... these "amateur" devices are hopeless.
278 The only thing, that I can say now:
279 It is very sad that we need to keep ugly obsolete
280 code to make them happy.
281
282 They should be moved to more reasonable state, now
283 they use rebuild_header INSTEAD OF hard_start_xmit!!!
284 Besides that, they are sort of out of date
285 (a lot of redundant clones/copies, useless in 2.1),
286 I wonder why people believe that they work.
287 */
288 switch (dev->type) {
289 default:
290 break;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900291 case ARPHRD_ROSE:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
293 case ARPHRD_AX25:
294#if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
295 case ARPHRD_NETROM:
296#endif
297 neigh->ops = &arp_broken_ops;
298 neigh->output = neigh->ops->output;
299 return 0;
Changli Gaodeffd772010-09-02 03:56:51 +0000300#else
301 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302#endif
Changli Gaodeffd772010-09-02 03:56:51 +0000303 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304#endif
305 if (neigh->type == RTN_MULTICAST) {
306 neigh->nud_state = NUD_NOARP;
307 arp_mc_map(addr, neigh->ha, dev, 1);
Changli Gaodeffd772010-09-02 03:56:51 +0000308 } else if (dev->flags & (IFF_NOARP | IFF_LOOPBACK)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 neigh->nud_state = NUD_NOARP;
310 memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
Changli Gaodeffd772010-09-02 03:56:51 +0000311 } else if (neigh->type == RTN_BROADCAST ||
312 (dev->flags & IFF_POINTOPOINT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 neigh->nud_state = NUD_NOARP;
314 memcpy(neigh->ha, dev->broadcast, dev->addr_len);
315 }
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700316
317 if (dev->header_ops->cache)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 neigh->ops = &arp_hh_ops;
319 else
320 neigh->ops = &arp_generic_ops;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700321
Changli Gaodeffd772010-09-02 03:56:51 +0000322 if (neigh->nud_state & NUD_VALID)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 neigh->output = neigh->ops->connected_output;
324 else
325 neigh->output = neigh->ops->output;
326 }
327 return 0;
328}
329
330static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb)
331{
332 dst_link_failure(skb);
333 kfree_skb(skb);
334}
335
336static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb)
337{
Al Viroa61ced52006-09-26 21:27:54 -0700338 __be32 saddr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 u8 *dst_ha = NULL;
340 struct net_device *dev = neigh->dev;
Changli Gaodeffd772010-09-02 03:56:51 +0000341 __be32 target = *(__be32 *)neigh->primary_key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 int probes = atomic_read(&neigh->probes);
Eric Dumazet4b4194c2010-06-22 07:43:15 +0000343 struct in_device *in_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
Eric Dumazet4b4194c2010-06-22 07:43:15 +0000345 rcu_read_lock();
346 in_dev = __in_dev_get_rcu(dev);
347 if (!in_dev) {
348 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 return;
Eric Dumazet4b4194c2010-06-22 07:43:15 +0000350 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 switch (IN_DEV_ARP_ANNOUNCE(in_dev)) {
352 default:
353 case 0: /* By default announce any local IP */
Changli Gaodeffd772010-09-02 03:56:51 +0000354 if (skb && inet_addr_type(dev_net(dev),
355 ip_hdr(skb)->saddr) == RTN_LOCAL)
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700356 saddr = ip_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 break;
358 case 1: /* Restrict announcements of saddr in same subnet */
359 if (!skb)
360 break;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700361 saddr = ip_hdr(skb)->saddr;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900362 if (inet_addr_type(dev_net(dev), saddr) == RTN_LOCAL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 /* saddr should be known to target */
364 if (inet_addr_onlink(in_dev, target, saddr))
365 break;
366 }
367 saddr = 0;
368 break;
369 case 2: /* Avoid secondary IPs, get a primary/preferred one */
370 break;
371 }
Eric Dumazet4b4194c2010-06-22 07:43:15 +0000372 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 if (!saddr)
375 saddr = inet_select_addr(dev, target, RT_SCOPE_LINK);
376
Changli Gaodeffd772010-09-02 03:56:51 +0000377 probes -= neigh->parms->ucast_probes;
378 if (probes < 0) {
379 if (!(neigh->nud_state & NUD_VALID))
380 printk(KERN_DEBUG
381 "trying to ucast probe in NUD_INVALID\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 dst_ha = neigh->ha;
David S. Miller9ff56602008-02-17 18:39:54 -0800383 read_lock_bh(&neigh->lock);
Changli Gaodeffd772010-09-02 03:56:51 +0000384 } else {
385 probes -= neigh->parms->app_probes;
386 if (probes < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387#ifdef CONFIG_ARPD
Changli Gaodeffd772010-09-02 03:56:51 +0000388 neigh_app_ns(neigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389#endif
Changli Gaodeffd772010-09-02 03:56:51 +0000390 return;
391 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 }
393
394 arp_send(ARPOP_REQUEST, ETH_P_ARP, target, dev, saddr,
395 dst_ha, dev->dev_addr, NULL);
David S. Miller9ff56602008-02-17 18:39:54 -0800396 if (dst_ha)
397 read_unlock_bh(&neigh->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398}
399
Denis V. Lunev9bd85e32008-01-14 23:05:55 -0800400static int arp_ignore(struct in_device *in_dev, __be32 sip, __be32 tip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401{
402 int scope;
403
404 switch (IN_DEV_ARP_IGNORE(in_dev)) {
405 case 0: /* Reply, the tip is already validated */
406 return 0;
407 case 1: /* Reply only if tip is configured on the incoming interface */
408 sip = 0;
409 scope = RT_SCOPE_HOST;
410 break;
411 case 2: /*
412 * Reply only if tip is configured on the incoming interface
413 * and is in same subnet as sip
414 */
415 scope = RT_SCOPE_HOST;
416 break;
417 case 3: /* Do not reply for scope host addresses */
418 sip = 0;
419 scope = RT_SCOPE_LINK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 break;
421 case 4: /* Reserved */
422 case 5:
423 case 6:
424 case 7:
425 return 0;
426 case 8: /* Do not reply */
427 return 1;
428 default:
429 return 0;
430 }
Denis V. Lunev9bd85e32008-01-14 23:05:55 -0800431 return !inet_confirm_addr(in_dev, sip, tip, scope);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432}
433
Al Viroed9bad02006-09-27 18:36:36 -0700434static int arp_filter(__be32 sip, __be32 tip, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435{
Changli Gao58116622010-11-12 18:43:55 +0000436 struct flowi fl = { .fl4_dst = sip,
437 .fl4_src = tip };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 struct rtable *rt;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900439 int flag = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 /*unsigned long now; */
Pavel Emelyanovca12a1a2008-07-16 20:28:42 -0700441 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442
Pavel Emelyanovca12a1a2008-07-16 20:28:42 -0700443 if (ip_route_output_key(net, &rt, &fl) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 return 1;
Changli Gaod8d1f302010-06-10 23:31:35 -0700445 if (rt->dst.dev != dev) {
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700446 NET_INC_STATS_BH(net, LINUX_MIB_ARPFILTER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 flag = 1;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900448 }
449 ip_rt_put(rt);
450 return flag;
451}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452
453/* OBSOLETE FUNCTIONS */
454
455/*
456 * Find an arp mapping in the cache. If not found, post a request.
457 *
458 * It is very UGLY routine: it DOES NOT use skb->dst->neighbour,
459 * even if it exists. It is supposed that skb->dev was mangled
460 * by a virtual device (eql, shaper). Nobody but broken devices
461 * is allowed to use this function, it is scheduled to be removed. --ANK
462 */
463
Changli Gaodeffd772010-09-02 03:56:51 +0000464static int arp_set_predefined(int addr_hint, unsigned char *haddr,
465 __be32 paddr, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466{
467 switch (addr_hint) {
468 case RTN_LOCAL:
469 printk(KERN_DEBUG "ARP: arp called for own IP address\n");
470 memcpy(haddr, dev->dev_addr, dev->addr_len);
471 return 1;
472 case RTN_MULTICAST:
473 arp_mc_map(paddr, haddr, dev, 1);
474 return 1;
475 case RTN_BROADCAST:
476 memcpy(haddr, dev->broadcast, dev->addr_len);
477 return 1;
478 }
479 return 0;
480}
481
482
483int arp_find(unsigned char *haddr, struct sk_buff *skb)
484{
485 struct net_device *dev = skb->dev;
Al Virofd683222006-09-26 22:17:51 -0700486 __be32 paddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 struct neighbour *n;
488
Eric Dumazetadf30902009-06-02 05:19:30 +0000489 if (!skb_dst(skb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 printk(KERN_DEBUG "arp_find is called with dst==NULL\n");
491 kfree_skb(skb);
492 return 1;
493 }
494
Eric Dumazet511c3f92009-06-02 05:14:27 +0000495 paddr = skb_rtable(skb)->rt_gateway;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496
Changli Gaodeffd772010-09-02 03:56:51 +0000497 if (arp_set_predefined(inet_addr_type(dev_net(dev), paddr), haddr,
498 paddr, dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 return 0;
500
501 n = __neigh_lookup(&arp_tbl, &paddr, dev, 1);
502
503 if (n) {
504 n->used = jiffies;
Eric Dumazet0ed8ddf2010-10-07 10:44:07 +0000505 if (n->nud_state & NUD_VALID || neigh_event_send(n, skb) == 0) {
506 neigh_ha_snapshot(haddr, n, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 neigh_release(n);
508 return 0;
509 }
510 neigh_release(n);
511 } else
512 kfree_skb(skb);
513 return 1;
514}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000515EXPORT_SYMBOL(arp_find);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516
517/* END OF OBSOLETE FUNCTIONS */
518
519int arp_bind_neighbour(struct dst_entry *dst)
520{
521 struct net_device *dev = dst->dev;
522 struct neighbour *n = dst->neighbour;
523
524 if (dev == NULL)
525 return -EINVAL;
526 if (n == NULL) {
Jianjun Kongf4cca7f2008-11-03 02:48:14 -0800527 __be32 nexthop = ((struct rtable *)dst)->rt_gateway;
Changli Gaodeffd772010-09-02 03:56:51 +0000528 if (dev->flags & (IFF_LOOPBACK | IFF_POINTOPOINT))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 nexthop = 0;
530 n = __neigh_lookup_errno(
531#if defined(CONFIG_ATM_CLIP) || defined(CONFIG_ATM_CLIP_MODULE)
Changli Gaodeffd772010-09-02 03:56:51 +0000532 dev->type == ARPHRD_ATM ?
533 clip_tbl_hook :
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534#endif
Changli Gaodeffd772010-09-02 03:56:51 +0000535 &arp_tbl, &nexthop, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 if (IS_ERR(n))
537 return PTR_ERR(n);
538 dst->neighbour = n;
539 }
540 return 0;
541}
542
543/*
544 * Check if we can use proxy ARP for this path
545 */
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +0000546static inline int arp_fwd_proxy(struct in_device *in_dev,
547 struct net_device *dev, struct rtable *rt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548{
549 struct in_device *out_dev;
550 int imi, omi = -1;
551
Changli Gaod8d1f302010-06-10 23:31:35 -0700552 if (rt->dst.dev == dev)
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +0000553 return 0;
554
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 if (!IN_DEV_PROXY_ARP(in_dev))
556 return 0;
Changli Gaodeffd772010-09-02 03:56:51 +0000557 imi = IN_DEV_MEDIUM_ID(in_dev);
558 if (imi == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 return 1;
560 if (imi == -1)
561 return 0;
562
563 /* place to check for proxy_arp for routes */
564
Changli Gaod8d1f302010-06-10 23:31:35 -0700565 out_dev = __in_dev_get_rcu(rt->dst.dev);
Eric Dumazetfaa9dcf2010-06-03 04:09:10 +0000566 if (out_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 omi = IN_DEV_MEDIUM_ID(out_dev);
Eric Dumazetfaa9dcf2010-06-03 04:09:10 +0000568
Eric Dumazeta02cec22010-09-22 20:43:57 +0000569 return omi != imi && omi != -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570}
571
572/*
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +0000573 * Check for RFC3069 proxy arp private VLAN (allow to send back to same dev)
574 *
575 * RFC3069 supports proxy arp replies back to the same interface. This
576 * is done to support (ethernet) switch features, like RFC 3069, where
577 * the individual ports are not allowed to communicate with each
578 * other, BUT they are allowed to talk to the upstream router. As
579 * described in RFC 3069, it is possible to allow these hosts to
580 * communicate through the upstream router, by proxy_arp'ing.
581 *
582 * RFC 3069: "VLAN Aggregation for Efficient IP Address Allocation"
583 *
584 * This technology is known by different names:
585 * In RFC 3069 it is called VLAN Aggregation.
586 * Cisco and Allied Telesyn call it Private VLAN.
587 * Hewlett-Packard call it Source-Port filtering or port-isolation.
588 * Ericsson call it MAC-Forced Forwarding (RFC Draft).
589 *
590 */
591static inline int arp_fwd_pvlan(struct in_device *in_dev,
592 struct net_device *dev, struct rtable *rt,
593 __be32 sip, __be32 tip)
594{
595 /* Private VLAN is only concerned about the same ethernet segment */
Changli Gaod8d1f302010-06-10 23:31:35 -0700596 if (rt->dst.dev != dev)
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +0000597 return 0;
598
599 /* Don't reply on self probes (often done by windowz boxes)*/
600 if (sip == tip)
601 return 0;
602
603 if (IN_DEV_PROXY_ARP_PVLAN(in_dev))
604 return 1;
605 else
606 return 0;
607}
608
609/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 * Interface to link layer: send routine and receive handler.
611 */
612
613/*
614 * Create an arp packet. If (dest_hw == NULL), we create a broadcast
615 * message.
616 */
Al Viroed9bad02006-09-27 18:36:36 -0700617struct sk_buff *arp_create(int type, int ptype, __be32 dest_ip,
618 struct net_device *dev, __be32 src_ip,
Jan Engelhardtabfdf1c2008-01-31 03:59:24 -0800619 const unsigned char *dest_hw,
620 const unsigned char *src_hw,
621 const unsigned char *target_hw)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622{
623 struct sk_buff *skb;
624 struct arphdr *arp;
625 unsigned char *arp_ptr;
626
627 /*
628 * Allocate a buffer
629 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900630
Johannes Bergf5184d22008-05-12 20:48:31 -0700631 skb = alloc_skb(arp_hdr_len(dev) + LL_ALLOCATED_SPACE(dev), GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 if (skb == NULL)
633 return NULL;
634
635 skb_reserve(skb, LL_RESERVED_SPACE(dev));
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -0700636 skb_reset_network_header(skb);
Pavel Emelyanov988b7052008-03-03 12:20:57 -0800637 arp = (struct arphdr *) skb_put(skb, arp_hdr_len(dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 skb->dev = dev;
639 skb->protocol = htons(ETH_P_ARP);
640 if (src_hw == NULL)
641 src_hw = dev->dev_addr;
642 if (dest_hw == NULL)
643 dest_hw = dev->broadcast;
644
645 /*
646 * Fill the device header for the ARP frame
647 */
Stephen Hemminger0c4e8582007-10-09 01:36:32 -0700648 if (dev_hard_header(skb, dev, ptype, dest_hw, src_hw, skb->len) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 goto out;
650
651 /*
652 * Fill out the arp protocol part.
653 *
654 * The arp hardware type should match the device type, except for FDDI,
655 * which (according to RFC 1390) should always equal 1 (Ethernet).
656 */
657 /*
658 * Exceptions everywhere. AX.25 uses the AX.25 PID value not the
659 * DIX code for the protocol. Make these device structure fields.
660 */
661 switch (dev->type) {
662 default:
663 arp->ar_hrd = htons(dev->type);
664 arp->ar_pro = htons(ETH_P_IP);
665 break;
666
667#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
668 case ARPHRD_AX25:
669 arp->ar_hrd = htons(ARPHRD_AX25);
670 arp->ar_pro = htons(AX25_P_IP);
671 break;
672
673#if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
674 case ARPHRD_NETROM:
675 arp->ar_hrd = htons(ARPHRD_NETROM);
676 arp->ar_pro = htons(AX25_P_IP);
677 break;
678#endif
679#endif
680
David S. Millerf0ecde12010-05-10 04:59:07 -0700681#if defined(CONFIG_FDDI) || defined(CONFIG_FDDI_MODULE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 case ARPHRD_FDDI:
683 arp->ar_hrd = htons(ARPHRD_ETHER);
684 arp->ar_pro = htons(ETH_P_IP);
685 break;
686#endif
David S. Millerf0ecde12010-05-10 04:59:07 -0700687#if defined(CONFIG_TR) || defined(CONFIG_TR_MODULE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 case ARPHRD_IEEE802_TR:
689 arp->ar_hrd = htons(ARPHRD_IEEE802);
690 arp->ar_pro = htons(ETH_P_IP);
691 break;
692#endif
693 }
694
695 arp->ar_hln = dev->addr_len;
696 arp->ar_pln = 4;
697 arp->ar_op = htons(type);
698
Changli Gaodeffd772010-09-02 03:56:51 +0000699 arp_ptr = (unsigned char *)(arp + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700
701 memcpy(arp_ptr, src_hw, dev->addr_len);
Jianjun Kongf4cca7f2008-11-03 02:48:14 -0800702 arp_ptr += dev->addr_len;
703 memcpy(arp_ptr, &src_ip, 4);
704 arp_ptr += 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 if (target_hw != NULL)
706 memcpy(arp_ptr, target_hw, dev->addr_len);
707 else
708 memset(arp_ptr, 0, dev->addr_len);
Jianjun Kongf4cca7f2008-11-03 02:48:14 -0800709 arp_ptr += dev->addr_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 memcpy(arp_ptr, &dest_ip, 4);
711
712 return skb;
713
714out:
715 kfree_skb(skb);
716 return NULL;
717}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000718EXPORT_SYMBOL(arp_create);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719
720/*
721 * Send an arp packet.
722 */
723void arp_xmit(struct sk_buff *skb)
724{
725 /* Send it off, maybe filter it using firewalling first. */
Jan Engelhardtfdc93142008-10-20 03:34:51 -0700726 NF_HOOK(NFPROTO_ARP, NF_ARP_OUT, skb, NULL, skb->dev, dev_queue_xmit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000728EXPORT_SYMBOL(arp_xmit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729
730/*
731 * Create and send an arp packet.
732 */
Al Viroed9bad02006-09-27 18:36:36 -0700733void arp_send(int type, int ptype, __be32 dest_ip,
734 struct net_device *dev, __be32 src_ip,
Jan Engelhardtabfdf1c2008-01-31 03:59:24 -0800735 const unsigned char *dest_hw, const unsigned char *src_hw,
736 const unsigned char *target_hw)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737{
738 struct sk_buff *skb;
739
740 /*
741 * No arp on this interface.
742 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900743
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 if (dev->flags&IFF_NOARP)
745 return;
746
747 skb = arp_create(type, ptype, dest_ip, dev, src_ip,
748 dest_hw, src_hw, target_hw);
Changli Gaodeffd772010-09-02 03:56:51 +0000749 if (skb == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751
752 arp_xmit(skb);
753}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000754EXPORT_SYMBOL(arp_send);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756/*
757 * Process an arp request.
758 */
759
760static int arp_process(struct sk_buff *skb)
761{
762 struct net_device *dev = skb->dev;
Eric Dumazetfaa9dcf2010-06-03 04:09:10 +0000763 struct in_device *in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 struct arphdr *arp;
765 unsigned char *arp_ptr;
766 struct rtable *rt;
Mark Rydene0260fe2007-12-19 23:38:11 -0800767 unsigned char *sha;
Al Viro9e12bb22006-09-26 21:25:20 -0700768 __be32 sip, tip;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 u16 dev_type = dev->type;
770 int addr_type;
771 struct neighbour *n;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900772 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773
774 /* arp_rcv below verifies the ARP header and verifies the device
775 * is ARP'able.
776 */
777
778 if (in_dev == NULL)
779 goto out;
780
Arnaldo Carvalho de Melod0a92be2007-03-12 20:56:31 -0300781 arp = arp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782
783 switch (dev_type) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900784 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 if (arp->ar_pro != htons(ETH_P_IP) ||
786 htons(dev_type) != arp->ar_hrd)
787 goto out;
788 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 case ARPHRD_ETHER:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 case ARPHRD_IEEE802_TR:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 case ARPHRD_FDDI:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 case ARPHRD_IEEE802:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 /*
794 * ETHERNET, Token Ring and Fibre Channel (which are IEEE 802
795 * devices, according to RFC 2625) devices will accept ARP
796 * hardware types of either 1 (Ethernet) or 6 (IEEE 802.2).
797 * This is the case also of FDDI, where the RFC 1390 says that
798 * FDDI devices should accept ARP hardware of (1) Ethernet,
799 * however, to be more robust, we'll accept both 1 (Ethernet)
800 * or 6 (IEEE 802.2)
801 */
802 if ((arp->ar_hrd != htons(ARPHRD_ETHER) &&
803 arp->ar_hrd != htons(ARPHRD_IEEE802)) ||
804 arp->ar_pro != htons(ETH_P_IP))
805 goto out;
806 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 case ARPHRD_AX25:
808 if (arp->ar_pro != htons(AX25_P_IP) ||
809 arp->ar_hrd != htons(ARPHRD_AX25))
810 goto out;
811 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 case ARPHRD_NETROM:
813 if (arp->ar_pro != htons(AX25_P_IP) ||
814 arp->ar_hrd != htons(ARPHRD_NETROM))
815 goto out;
816 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 }
818
819 /* Understand only these message types */
820
821 if (arp->ar_op != htons(ARPOP_REPLY) &&
822 arp->ar_op != htons(ARPOP_REQUEST))
823 goto out;
824
825/*
826 * Extract fields
827 */
Changli Gaodeffd772010-09-02 03:56:51 +0000828 arp_ptr = (unsigned char *)(arp + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 sha = arp_ptr;
830 arp_ptr += dev->addr_len;
831 memcpy(&sip, arp_ptr, 4);
832 arp_ptr += 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 arp_ptr += dev->addr_len;
834 memcpy(&tip, arp_ptr, 4);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900835/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 * Check for bad requests for 127.x.x.x and requests for multicast
837 * addresses. If this is one such, delete it.
838 */
Joe Perchesf97c1e02007-12-16 13:45:43 -0800839 if (ipv4_is_loopback(tip) || ipv4_is_multicast(tip))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 goto out;
841
842/*
843 * Special case: We must set Frame Relay source Q.922 address
844 */
845 if (dev_type == ARPHRD_DLCI)
846 sha = dev->broadcast;
847
848/*
849 * Process entry. The idea here is we want to send a reply if it is a
850 * request for us or if it is a request for someone else that we hold
851 * a proxy for. We want to add an entry to our cache if it is a reply
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900852 * to us or if it is a request for our address.
853 * (The assumption for this last is that if someone is requesting our
854 * address, they are probably intending to talk to us, so it saves time
855 * if we cache their address. Their address is also probably not in
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 * our cache, since ours is not in their cache.)
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900857 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 * Putting this another way, we only care about replies if they are to
859 * us, in which case we add them to the cache. For requests, we care
860 * about those for us and those for our proxies. We reply to both,
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900861 * and in the case of requests for us we add the requester to the arp
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 * cache.
863 */
864
Eric W. Biedermanf8a68e72009-06-30 16:27:17 +0000865 /* Special case: IPv4 duplicate address detection packet (RFC2131) */
866 if (sip == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 if (arp->ar_op == htons(ARPOP_REQUEST) &&
Denis V. Lunev49e8a272008-03-24 15:28:12 -0700868 inet_addr_type(net, tip) == RTN_LOCAL &&
Denis V. Lunev9bd85e32008-01-14 23:05:55 -0800869 !arp_ignore(in_dev, sip, tip))
Jonas Danielssonb4a98112007-11-20 17:38:16 -0800870 arp_send(ARPOP_REPLY, ETH_P_ARP, sip, dev, tip, sha,
871 dev->dev_addr, sha);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 goto out;
873 }
874
875 if (arp->ar_op == htons(ARPOP_REQUEST) &&
Eric Dumazet4a944452010-05-10 11:33:06 +0000876 ip_route_input_noref(skb, tip, sip, 0, dev) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877
Eric Dumazet511c3f92009-06-02 05:14:27 +0000878 rt = skb_rtable(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 addr_type = rt->rt_type;
880
881 if (addr_type == RTN_LOCAL) {
Changli Gaodeffd772010-09-02 03:56:51 +0000882 int dont_send;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883
Changli Gaodeffd772010-09-02 03:56:51 +0000884 dont_send = arp_ignore(in_dev, sip, tip);
Ben Greear8164f1b2008-11-16 19:19:38 -0800885 if (!dont_send && IN_DEV_ARPFILTER(in_dev))
Changli Gaoae9c4162010-12-01 20:07:31 +0000886 dont_send = arp_filter(sip, tip, dev);
Ben Greear8164f1b2008-11-16 19:19:38 -0800887 if (!dont_send) {
888 n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
889 if (n) {
Changli Gaodeffd772010-09-02 03:56:51 +0000890 arp_send(ARPOP_REPLY, ETH_P_ARP, sip,
891 dev, tip, sha, dev->dev_addr,
892 sha);
Ben Greear8164f1b2008-11-16 19:19:38 -0800893 neigh_release(n);
894 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 }
896 goto out;
897 } else if (IN_DEV_FORWARD(in_dev)) {
Jesper Dangaard Brouer65324142010-01-05 05:50:47 +0000898 if (addr_type == RTN_UNICAST &&
899 (arp_fwd_proxy(in_dev, dev, rt) ||
900 arp_fwd_pvlan(in_dev, dev, rt, sip, tip) ||
Changli Gaodeffd772010-09-02 03:56:51 +0000901 pneigh_lookup(&arp_tbl, net, &tip, dev, 0))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
903 if (n)
904 neigh_release(n);
905
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900906 if (NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 skb->pkt_type == PACKET_HOST ||
908 in_dev->arp_parms->proxy_delay == 0) {
Changli Gaodeffd772010-09-02 03:56:51 +0000909 arp_send(ARPOP_REPLY, ETH_P_ARP, sip,
910 dev, tip, sha, dev->dev_addr,
911 sha);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 } else {
Changli Gaodeffd772010-09-02 03:56:51 +0000913 pneigh_enqueue(&arp_tbl,
914 in_dev->arp_parms, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 return 0;
916 }
917 goto out;
918 }
919 }
920 }
921
922 /* Update our ARP tables */
923
924 n = __neigh_lookup(&arp_tbl, &sip, dev, 0);
925
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900926 if (IPV4_DEVCONF_ALL(dev_net(dev), ARP_ACCEPT)) {
Neil Hormanabd596a2006-03-20 22:39:47 -0800927 /* Unsolicited ARP is not accepted by default.
928 It is possible, that this option should be enabled for some
929 devices (strip is candidate)
930 */
931 if (n == NULL &&
Octavian Purdila6d955182010-01-18 12:58:44 +0000932 (arp->ar_op == htons(ARPOP_REPLY) ||
933 (arp->ar_op == htons(ARPOP_REQUEST) && tip == sip)) &&
Denis V. Lunev49e8a272008-03-24 15:28:12 -0700934 inet_addr_type(net, sip) == RTN_UNICAST)
Jean Delvare1b1ac752007-07-14 20:51:44 -0700935 n = __neigh_lookup(&arp_tbl, &sip, dev, 1);
Neil Hormanabd596a2006-03-20 22:39:47 -0800936 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937
938 if (n) {
939 int state = NUD_REACHABLE;
940 int override;
941
942 /* If several different ARP replies follows back-to-back,
943 use the FIRST one. It is possible, if several proxy
944 agents are active. Taking the first reply prevents
945 arp trashing and chooses the fastest router.
946 */
947 override = time_after(jiffies, n->updated + n->parms->locktime);
948
949 /* Broadcast replies and request packets
950 do not assert neighbour reachability.
951 */
952 if (arp->ar_op != htons(ARPOP_REPLY) ||
953 skb->pkt_type != PACKET_HOST)
954 state = NUD_STALE;
Changli Gaodeffd772010-09-02 03:56:51 +0000955 neigh_update(n, sha, state,
956 override ? NEIGH_UPDATE_F_OVERRIDE : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 neigh_release(n);
958 }
959
960out:
Neil Hormanead2ceb2009-03-11 09:49:55 +0000961 consume_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 return 0;
963}
964
Herbert Xu444fc8f2005-10-03 14:18:10 -0700965static void parp_redo(struct sk_buff *skb)
966{
967 arp_process(skb);
968}
969
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970
971/*
972 * Receive an arp request from the device layer.
973 */
974
Adrian Bunk6c97e722006-04-12 13:57:59 -0700975static int arp_rcv(struct sk_buff *skb, struct net_device *dev,
976 struct packet_type *pt, struct net_device *orig_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977{
978 struct arphdr *arp;
979
980 /* ARP header, plus 2 device addresses, plus 2 IP addresses. */
Pavel Emelyanov988b7052008-03-03 12:20:57 -0800981 if (!pskb_may_pull(skb, arp_hdr_len(dev)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982 goto freeskb;
983
Arnaldo Carvalho de Melod0a92be2007-03-12 20:56:31 -0300984 arp = arp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 if (arp->ar_hln != dev->addr_len ||
986 dev->flags & IFF_NOARP ||
987 skb->pkt_type == PACKET_OTHERHOST ||
988 skb->pkt_type == PACKET_LOOPBACK ||
989 arp->ar_pln != 4)
990 goto freeskb;
991
Changli Gaodeffd772010-09-02 03:56:51 +0000992 skb = skb_share_check(skb, GFP_ATOMIC);
993 if (skb == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 goto out_of_mem;
995
Patrick McHardya61bbcf2005-08-14 17:24:31 -0700996 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
997
Jan Engelhardtfdc93142008-10-20 03:34:51 -0700998 return NF_HOOK(NFPROTO_ARP, NF_ARP_IN, skb, dev, NULL, arp_process);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999
1000freeskb:
1001 kfree_skb(skb);
1002out_of_mem:
1003 return 0;
1004}
1005
1006/*
1007 * User level interface (ioctl)
1008 */
1009
1010/*
1011 * Set (create) an ARP cache entry.
1012 */
1013
Pavel Emelyanov32e569b2007-12-16 13:30:39 -08001014static int arp_req_set_proxy(struct net *net, struct net_device *dev, int on)
Pavel Emelyanovf8b33fd2007-12-05 21:20:50 -08001015{
1016 if (dev == NULL) {
Pavel Emelyanov586f1212007-12-16 13:32:48 -08001017 IPV4_DEVCONF_ALL(net, PROXY_ARP) = on;
Pavel Emelyanovf8b33fd2007-12-05 21:20:50 -08001018 return 0;
1019 }
Eric Dumazetc5066532011-01-24 13:16:16 -08001020 if (__in_dev_get_rtnl(dev)) {
1021 IN_DEV_CONF_SET(__in_dev_get_rtnl(dev), PROXY_ARP, on);
Pavel Emelyanovf8b33fd2007-12-05 21:20:50 -08001022 return 0;
1023 }
1024 return -ENXIO;
1025}
1026
Pavel Emelyanov32e569b2007-12-16 13:30:39 -08001027static int arp_req_set_public(struct net *net, struct arpreq *r,
1028 struct net_device *dev)
Pavel Emelyanov43dc1702007-12-05 21:19:44 -08001029{
1030 __be32 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
1031 __be32 mask = ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr;
1032
1033 if (mask && mask != htonl(0xFFFFFFFF))
1034 return -EINVAL;
1035 if (!dev && (r->arp_flags & ATF_COM)) {
Eric Dumazet941666c2010-12-05 01:23:53 +00001036 dev = dev_getbyhwaddr_rcu(net, r->arp_ha.sa_family,
Changli Gaodeffd772010-09-02 03:56:51 +00001037 r->arp_ha.sa_data);
Pavel Emelyanov43dc1702007-12-05 21:19:44 -08001038 if (!dev)
1039 return -ENODEV;
1040 }
1041 if (mask) {
Denis V. Lunev2db82b52008-01-14 22:58:55 -08001042 if (pneigh_lookup(&arp_tbl, net, &ip, dev, 1) == NULL)
Pavel Emelyanov43dc1702007-12-05 21:19:44 -08001043 return -ENOBUFS;
1044 return 0;
1045 }
Pavel Emelyanovf8b33fd2007-12-05 21:20:50 -08001046
Pavel Emelyanov32e569b2007-12-16 13:30:39 -08001047 return arp_req_set_proxy(net, dev, 1);
Pavel Emelyanov43dc1702007-12-05 21:19:44 -08001048}
1049
Pavel Emelyanov32e569b2007-12-16 13:30:39 -08001050static int arp_req_set(struct net *net, struct arpreq *r,
Changli Gaodeffd772010-09-02 03:56:51 +00001051 struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052{
Pavel Emelyanov43dc1702007-12-05 21:19:44 -08001053 __be32 ip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 struct neighbour *neigh;
1055 int err;
1056
Pavel Emelyanov43dc1702007-12-05 21:19:44 -08001057 if (r->arp_flags & ATF_PUBL)
Pavel Emelyanov32e569b2007-12-16 13:30:39 -08001058 return arp_req_set_public(net, r, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059
Pavel Emelyanov43dc1702007-12-05 21:19:44 -08001060 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 if (r->arp_flags & ATF_PERM)
1062 r->arp_flags |= ATF_COM;
1063 if (dev == NULL) {
Changli Gao58116622010-11-12 18:43:55 +00001064 struct flowi fl = { .fl4_dst = ip,
1065 .fl4_tos = RTO_ONLINK };
Changli Gaodeffd772010-09-02 03:56:51 +00001066 struct rtable *rt;
1067 err = ip_route_output_key(net, &rt, &fl);
1068 if (err != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 return err;
Changli Gaod8d1f302010-06-10 23:31:35 -07001070 dev = rt->dst.dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 ip_rt_put(rt);
1072 if (!dev)
1073 return -EINVAL;
1074 }
1075 switch (dev->type) {
David S. Millerf0ecde12010-05-10 04:59:07 -07001076#if defined(CONFIG_FDDI) || defined(CONFIG_FDDI_MODULE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 case ARPHRD_FDDI:
1078 /*
1079 * According to RFC 1390, FDDI devices should accept ARP
1080 * hardware types of 1 (Ethernet). However, to be more
1081 * robust, we'll accept hardware types of either 1 (Ethernet)
1082 * or 6 (IEEE 802.2).
1083 */
1084 if (r->arp_ha.sa_family != ARPHRD_FDDI &&
1085 r->arp_ha.sa_family != ARPHRD_ETHER &&
1086 r->arp_ha.sa_family != ARPHRD_IEEE802)
1087 return -EINVAL;
1088 break;
1089#endif
1090 default:
1091 if (r->arp_ha.sa_family != dev->type)
1092 return -EINVAL;
1093 break;
1094 }
1095
1096 neigh = __neigh_lookup_errno(&arp_tbl, &ip, dev);
1097 err = PTR_ERR(neigh);
1098 if (!IS_ERR(neigh)) {
1099 unsigned state = NUD_STALE;
1100 if (r->arp_flags & ATF_PERM)
1101 state = NUD_PERMANENT;
Changli Gaodeffd772010-09-02 03:56:51 +00001102 err = neigh_update(neigh, (r->arp_flags & ATF_COM) ?
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001103 r->arp_ha.sa_data : NULL, state,
Changli Gaodeffd772010-09-02 03:56:51 +00001104 NEIGH_UPDATE_F_OVERRIDE |
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 NEIGH_UPDATE_F_ADMIN);
1106 neigh_release(neigh);
1107 }
1108 return err;
1109}
1110
1111static unsigned arp_state_to_flags(struct neighbour *neigh)
1112{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113 if (neigh->nud_state&NUD_PERMANENT)
Changli Gaodeffd772010-09-02 03:56:51 +00001114 return ATF_PERM | ATF_COM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 else if (neigh->nud_state&NUD_VALID)
Changli Gaodeffd772010-09-02 03:56:51 +00001116 return ATF_COM;
1117 else
1118 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119}
1120
1121/*
1122 * Get an ARP cache entry.
1123 */
1124
1125static int arp_req_get(struct arpreq *r, struct net_device *dev)
1126{
Al Viroed9bad02006-09-27 18:36:36 -07001127 __be32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 struct neighbour *neigh;
1129 int err = -ENXIO;
1130
1131 neigh = neigh_lookup(&arp_tbl, &ip, dev);
1132 if (neigh) {
1133 read_lock_bh(&neigh->lock);
1134 memcpy(r->arp_ha.sa_data, neigh->ha, dev->addr_len);
1135 r->arp_flags = arp_state_to_flags(neigh);
1136 read_unlock_bh(&neigh->lock);
1137 r->arp_ha.sa_family = dev->type;
1138 strlcpy(r->arp_dev, dev->name, sizeof(r->arp_dev));
1139 neigh_release(neigh);
1140 err = 0;
1141 }
1142 return err;
1143}
1144
Maxim Levitsky545ecdc2011-01-08 13:57:12 +00001145int arp_invalidate(struct net_device *dev, __be32 ip)
1146{
1147 struct neighbour *neigh = neigh_lookup(&arp_tbl, &ip, dev);
1148 int err = -ENXIO;
1149
1150 if (neigh) {
1151 if (neigh->nud_state & ~NUD_NOARP)
1152 err = neigh_update(neigh, NULL, NUD_FAILED,
1153 NEIGH_UPDATE_F_OVERRIDE|
1154 NEIGH_UPDATE_F_ADMIN);
1155 neigh_release(neigh);
1156 }
1157
1158 return err;
1159}
1160EXPORT_SYMBOL(arp_invalidate);
1161
Pavel Emelyanov32e569b2007-12-16 13:30:39 -08001162static int arp_req_delete_public(struct net *net, struct arpreq *r,
1163 struct net_device *dev)
Pavel Emelyanov46479b42007-12-05 21:20:18 -08001164{
1165 __be32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
1166 __be32 mask = ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr;
1167
1168 if (mask == htonl(0xFFFFFFFF))
Denis V. Lunev2db82b52008-01-14 22:58:55 -08001169 return pneigh_delete(&arp_tbl, net, &ip, dev);
Pavel Emelyanov46479b42007-12-05 21:20:18 -08001170
Pavel Emelyanovf8b33fd2007-12-05 21:20:50 -08001171 if (mask)
1172 return -EINVAL;
1173
Pavel Emelyanov32e569b2007-12-16 13:30:39 -08001174 return arp_req_set_proxy(net, dev, 0);
Pavel Emelyanov46479b42007-12-05 21:20:18 -08001175}
1176
Pavel Emelyanov32e569b2007-12-16 13:30:39 -08001177static int arp_req_delete(struct net *net, struct arpreq *r,
Changli Gaodeffd772010-09-02 03:56:51 +00001178 struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179{
1180 int err;
Pavel Emelyanov46479b42007-12-05 21:20:18 -08001181 __be32 ip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182
Pavel Emelyanov46479b42007-12-05 21:20:18 -08001183 if (r->arp_flags & ATF_PUBL)
Pavel Emelyanov32e569b2007-12-16 13:30:39 -08001184 return arp_req_delete_public(net, r, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185
Pavel Emelyanov46479b42007-12-05 21:20:18 -08001186 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 if (dev == NULL) {
Changli Gao58116622010-11-12 18:43:55 +00001188 struct flowi fl = { .fl4_dst = ip,
1189 .fl4_tos = RTO_ONLINK };
Changli Gaodeffd772010-09-02 03:56:51 +00001190 struct rtable *rt;
1191 err = ip_route_output_key(net, &rt, &fl);
1192 if (err != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 return err;
Changli Gaod8d1f302010-06-10 23:31:35 -07001194 dev = rt->dst.dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 ip_rt_put(rt);
1196 if (!dev)
1197 return -EINVAL;
1198 }
Maxim Levitsky545ecdc2011-01-08 13:57:12 +00001199 return arp_invalidate(dev, ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200}
1201
1202/*
1203 * Handle an ARP layer I/O control request.
1204 */
1205
Pavel Emelyanov32e569b2007-12-16 13:30:39 -08001206int arp_ioctl(struct net *net, unsigned int cmd, void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207{
1208 int err;
1209 struct arpreq r;
1210 struct net_device *dev = NULL;
1211
1212 switch (cmd) {
Changli Gaodeffd772010-09-02 03:56:51 +00001213 case SIOCDARP:
1214 case SIOCSARP:
1215 if (!capable(CAP_NET_ADMIN))
1216 return -EPERM;
1217 case SIOCGARP:
1218 err = copy_from_user(&r, arg, sizeof(struct arpreq));
1219 if (err)
1220 return -EFAULT;
1221 break;
1222 default:
1223 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 }
1225
1226 if (r.arp_pa.sa_family != AF_INET)
1227 return -EPFNOSUPPORT;
1228
1229 if (!(r.arp_flags & ATF_PUBL) &&
Changli Gaodeffd772010-09-02 03:56:51 +00001230 (r.arp_flags & (ATF_NETMASK | ATF_DONTPUB)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231 return -EINVAL;
1232 if (!(r.arp_flags & ATF_NETMASK))
1233 ((struct sockaddr_in *)&r.arp_netmask)->sin_addr.s_addr =
1234 htonl(0xFFFFFFFFUL);
Eric Dumazetc5066532011-01-24 13:16:16 -08001235 rtnl_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236 if (r.arp_dev[0]) {
1237 err = -ENODEV;
Eric Dumazetc5066532011-01-24 13:16:16 -08001238 dev = __dev_get_by_name(net, r.arp_dev);
Changli Gaodeffd772010-09-02 03:56:51 +00001239 if (dev == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240 goto out;
1241
1242 /* Mmmm... It is wrong... ARPHRD_NETROM==0 */
1243 if (!r.arp_ha.sa_family)
1244 r.arp_ha.sa_family = dev->type;
1245 err = -EINVAL;
1246 if ((r.arp_flags & ATF_COM) && r.arp_ha.sa_family != dev->type)
1247 goto out;
1248 } else if (cmd == SIOCGARP) {
1249 err = -ENODEV;
1250 goto out;
1251 }
1252
Stephen Hemminger132adf52007-03-08 20:44:43 -08001253 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 case SIOCDARP:
Pavel Emelyanov32e569b2007-12-16 13:30:39 -08001255 err = arp_req_delete(net, &r, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256 break;
1257 case SIOCSARP:
Pavel Emelyanov32e569b2007-12-16 13:30:39 -08001258 err = arp_req_set(net, &r, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 break;
1260 case SIOCGARP:
1261 err = arp_req_get(&r, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 break;
1263 }
1264out:
Eric Dumazetc5066532011-01-24 13:16:16 -08001265 rtnl_unlock();
Eric Dumazet941666c2010-12-05 01:23:53 +00001266 if (cmd == SIOCGARP && !err && copy_to_user(arg, &r, sizeof(r)))
1267 err = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 return err;
1269}
1270
Changli Gaodeffd772010-09-02 03:56:51 +00001271static int arp_netdev_event(struct notifier_block *this, unsigned long event,
1272 void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273{
1274 struct net_device *dev = ptr;
1275
1276 switch (event) {
1277 case NETDEV_CHANGEADDR:
1278 neigh_changeaddr(&arp_tbl, dev);
Denis V. Lunev76e6ebf2008-07-05 19:00:44 -07001279 rt_cache_flush(dev_net(dev), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 break;
1281 default:
1282 break;
1283 }
1284
1285 return NOTIFY_DONE;
1286}
1287
1288static struct notifier_block arp_netdev_notifier = {
1289 .notifier_call = arp_netdev_event,
1290};
1291
1292/* Note, that it is not on notifier chain.
1293 It is necessary, that this routine was called after route cache will be
1294 flushed.
1295 */
1296void arp_ifdown(struct net_device *dev)
1297{
1298 neigh_ifdown(&arp_tbl, dev);
1299}
1300
1301
1302/*
1303 * Called once on startup.
1304 */
1305
Stephen Hemminger7546dd92009-03-09 08:18:29 +00001306static struct packet_type arp_packet_type __read_mostly = {
Harvey Harrison09640e62009-02-01 00:45:17 -08001307 .type = cpu_to_be16(ETH_P_ARP),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 .func = arp_rcv,
1309};
1310
1311static int arp_proc_init(void);
1312
1313void __init arp_init(void)
1314{
1315 neigh_table_init(&arp_tbl);
1316
1317 dev_add_pack(&arp_packet_type);
1318 arp_proc_init();
1319#ifdef CONFIG_SYSCTL
Eric W. Biederman54716e32010-02-14 03:27:03 +00001320 neigh_sysctl_register(NULL, &arp_tbl.parms, "ipv4", NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321#endif
1322 register_netdevice_notifier(&arp_netdev_notifier);
1323}
1324
1325#ifdef CONFIG_PROC_FS
1326#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1327
1328/* ------------------------------------------------------------------------ */
1329/*
1330 * ax25 -> ASCII conversion
1331 */
1332static char *ax2asc2(ax25_address *a, char *buf)
1333{
1334 char c, *s;
1335 int n;
1336
1337 for (n = 0, s = buf; n < 6; n++) {
1338 c = (a->ax25_call[n] >> 1) & 0x7F;
1339
Changli Gaodeffd772010-09-02 03:56:51 +00001340 if (c != ' ')
1341 *s++ = c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001343
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 *s++ = '-';
Changli Gaodeffd772010-09-02 03:56:51 +00001345 n = (a->ax25_call[6] >> 1) & 0x0F;
1346 if (n > 9) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 *s++ = '1';
1348 n -= 10;
1349 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001350
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 *s++ = n + '0';
1352 *s++ = '\0';
1353
1354 if (*buf == '\0' || *buf == '-')
Changli Gaodeffd772010-09-02 03:56:51 +00001355 return "*";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356
1357 return buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358}
1359#endif /* CONFIG_AX25 */
1360
1361#define HBUFFERLEN 30
1362
1363static void arp_format_neigh_entry(struct seq_file *seq,
1364 struct neighbour *n)
1365{
1366 char hbuffer[HBUFFERLEN];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 int k, j;
1368 char tbuf[16];
1369 struct net_device *dev = n->dev;
1370 int hatype = dev->type;
1371
1372 read_lock(&n->lock);
1373 /* Convert hardware address to XX:XX:XX:XX ... form. */
1374#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1375 if (hatype == ARPHRD_AX25 || hatype == ARPHRD_NETROM)
1376 ax2asc2((ax25_address *)n->ha, hbuffer);
1377 else {
1378#endif
1379 for (k = 0, j = 0; k < HBUFFERLEN - 3 && j < dev->addr_len; j++) {
Denis Cheng51f82a22008-05-21 17:34:32 -07001380 hbuffer[k++] = hex_asc_hi(n->ha[j]);
1381 hbuffer[k++] = hex_asc_lo(n->ha[j]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 hbuffer[k++] = ':';
1383 }
roel kluina3e8ee62009-07-29 23:46:59 +00001384 if (k != 0)
1385 --k;
1386 hbuffer[k] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1388 }
1389#endif
Harvey Harrison673d57e2008-10-31 00:53:57 -07001390 sprintf(tbuf, "%pI4", n->primary_key);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391 seq_printf(seq, "%-16s 0x%-10x0x%-10x%s * %s\n",
1392 tbuf, hatype, arp_state_to_flags(n), hbuffer, dev->name);
1393 read_unlock(&n->lock);
1394}
1395
1396static void arp_format_pneigh_entry(struct seq_file *seq,
1397 struct pneigh_entry *n)
1398{
1399 struct net_device *dev = n->dev;
1400 int hatype = dev ? dev->type : 0;
1401 char tbuf[16];
1402
Harvey Harrison673d57e2008-10-31 00:53:57 -07001403 sprintf(tbuf, "%pI4", n->key);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 seq_printf(seq, "%-16s 0x%-10x0x%-10x%s * %s\n",
1405 tbuf, hatype, ATF_PUBL | ATF_PERM, "00:00:00:00:00:00",
1406 dev ? dev->name : "*");
1407}
1408
1409static int arp_seq_show(struct seq_file *seq, void *v)
1410{
1411 if (v == SEQ_START_TOKEN) {
1412 seq_puts(seq, "IP address HW type Flags "
1413 "HW address Mask Device\n");
1414 } else {
1415 struct neigh_seq_state *state = seq->private;
1416
1417 if (state->flags & NEIGH_SEQ_IS_PNEIGH)
1418 arp_format_pneigh_entry(seq, v);
1419 else
1420 arp_format_neigh_entry(seq, v);
1421 }
1422
1423 return 0;
1424}
1425
1426static void *arp_seq_start(struct seq_file *seq, loff_t *pos)
1427{
1428 /* Don't want to confuse "arp -a" w/ magic entries,
1429 * so we tell the generic iterator to skip NUD_NOARP.
1430 */
1431 return neigh_seq_start(seq, pos, &arp_tbl, NEIGH_SEQ_SKIP_NOARP);
1432}
1433
1434/* ------------------------------------------------------------------------ */
1435
Stephen Hemmingerf6908082007-03-12 14:34:29 -07001436static const struct seq_operations arp_seq_ops = {
Changli Gaodeffd772010-09-02 03:56:51 +00001437 .start = arp_seq_start,
1438 .next = neigh_seq_next,
1439 .stop = neigh_seq_stop,
1440 .show = arp_seq_show,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441};
1442
1443static int arp_seq_open(struct inode *inode, struct file *file)
1444{
Eric W. Biederman426b5302008-01-24 00:13:18 -08001445 return seq_open_net(inode, file, &arp_seq_ops,
1446 sizeof(struct neigh_seq_state));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447}
1448
Arjan van de Ven9a321442007-02-12 00:55:35 -08001449static const struct file_operations arp_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 .owner = THIS_MODULE,
1451 .open = arp_seq_open,
1452 .read = seq_read,
1453 .llseek = seq_lseek,
Eric W. Biederman426b5302008-01-24 00:13:18 -08001454 .release = seq_release_net,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455};
1456
Denis V. Lunevffc31d32008-03-24 15:28:43 -07001457
1458static int __net_init arp_net_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459{
Denis V. Lunevffc31d32008-03-24 15:28:43 -07001460 if (!proc_net_fops_create(net, "arp", S_IRUGO, &arp_seq_fops))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461 return -ENOMEM;
1462 return 0;
1463}
1464
Denis V. Lunevffc31d32008-03-24 15:28:43 -07001465static void __net_exit arp_net_exit(struct net *net)
1466{
1467 proc_net_remove(net, "arp");
1468}
1469
1470static struct pernet_operations arp_net_ops = {
1471 .init = arp_net_init,
1472 .exit = arp_net_exit,
1473};
1474
1475static int __init arp_proc_init(void)
1476{
1477 return register_pernet_subsys(&arp_net_ops);
1478}
1479
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480#else /* CONFIG_PROC_FS */
1481
1482static int __init arp_proc_init(void)
1483{
1484 return 0;
1485}
1486
1487#endif /* CONFIG_PROC_FS */