blob: 08174a2aa8789ad8b3adb49b9f1d0fc1ac6edd06 [file] [log] [blame]
Uwe Zeisbergerf30c2262006-10-03 23:01:26 +02001/* linux/net/ipv4/arp.c
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 *
3 * Version: $Id: arp.c,v 1.99 2001/08/30 22:55:42 davem Exp $
4 *
5 * Copyright (C) 1994 by Florian La Roche
6 *
7 * This module implements the Address Resolution Protocol ARP (RFC 826),
8 * which is used to convert IP addresses (or in the future maybe other
9 * high-level addresses) into a low-level hardware address (like an Ethernet
10 * address).
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
16 *
17 * Fixes:
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090018 * Alan Cox : Removed the Ethernet assumptions in
Linus Torvalds1da177e2005-04-16 15:20:36 -070019 * Florian's code
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090020 * Alan Cox : Fixed some small errors in the ARP
Linus Torvalds1da177e2005-04-16 15:20:36 -070021 * logic
22 * Alan Cox : Allow >4K in /proc
23 * Alan Cox : Make ARP add its own protocol entry
24 * Ross Martin : Rewrote arp_rcv() and arp_get_info()
25 * Stephen Henson : Add AX25 support to arp_get_info()
26 * Alan Cox : Drop data when a device is downed.
27 * Alan Cox : Use init_timer().
28 * Alan Cox : Double lock fixes.
29 * Martin Seine : Move the arphdr structure
30 * to if_arp.h for compatibility.
31 * with BSD based programs.
32 * Andrew Tridgell : Added ARP netmask code and
33 * re-arranged proxy handling.
34 * Alan Cox : Changed to use notifiers.
35 * Niibe Yutaka : Reply for this device or proxies only.
36 * Alan Cox : Don't proxy across hardware types!
37 * Jonathan Naylor : Added support for NET/ROM.
38 * Mike Shaver : RFC1122 checks.
39 * Jonathan Naylor : Only lookup the hardware address for
40 * the correct hardware type.
41 * Germano Caronni : Assorted subtle races.
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090042 * Craig Schlenter : Don't modify permanent entry
Linus Torvalds1da177e2005-04-16 15:20:36 -070043 * during arp_rcv.
44 * Russ Nelson : Tidied up a few bits.
45 * Alexey Kuznetsov: Major changes to caching and behaviour,
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090046 * eg intelligent arp probing and
Linus Torvalds1da177e2005-04-16 15:20:36 -070047 * generation
48 * of host down events.
49 * Alan Cox : Missing unlock in device events.
50 * Eckes : ARP ioctl control errors.
51 * Alexey Kuznetsov: Arp free fix.
52 * Manuel Rodriguez: Gratuitous ARP.
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090053 * Jonathan Layes : Added arpd support through kerneld
Linus Torvalds1da177e2005-04-16 15:20:36 -070054 * message queue (960314)
55 * Mike Shaver : /proc/sys/net/ipv4/arp_* support
56 * Mike McLagan : Routing by source
57 * Stuart Cheshire : Metricom and grat arp fixes
58 * *** FOR 2.1 clean this up ***
59 * Lawrence V. Stefani: (08/12/96) Added FDDI support.
60 * Alan Cox : Took the AP1000 nasty FDDI hack and
61 * folded into the mainstream FDDI code.
62 * Ack spit, Linus how did you allow that
63 * one in...
64 * Jes Sorensen : Make FDDI work again in 2.1.x and
65 * clean up the APFDDI & gen. FDDI bits.
66 * Alexey Kuznetsov: new arp state machine;
67 * now it is in net/core/neighbour.c.
68 * Krzysztof Halasa: Added Frame Relay ARP support.
69 * Arnaldo C. Melo : convert /proc/net/arp to seq_file
70 * Shmulik Hen: Split arp_send to arp_create and
71 * arp_xmit so intermediate drivers like
72 * bonding can change the skb before
73 * sending (e.g. insert 8021q tag).
74 * Harald Welte : convert to make use of jenkins hash
75 */
76
77#include <linux/module.h>
78#include <linux/types.h>
79#include <linux/string.h>
80#include <linux/kernel.h>
Randy Dunlap4fc268d2006-01-11 12:17:47 -080081#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070082#include <linux/socket.h>
83#include <linux/sockios.h>
84#include <linux/errno.h>
85#include <linux/in.h>
86#include <linux/mm.h>
87#include <linux/inet.h>
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020088#include <linux/inetdevice.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070089#include <linux/netdevice.h>
90#include <linux/etherdevice.h>
91#include <linux/fddidevice.h>
92#include <linux/if_arp.h>
93#include <linux/trdevice.h>
94#include <linux/skbuff.h>
95#include <linux/proc_fs.h>
96#include <linux/seq_file.h>
97#include <linux/stat.h>
98#include <linux/init.h>
99#include <linux/net.h>
100#include <linux/rcupdate.h>
101#include <linux/jhash.h>
102#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;
119#endif
120
121#include <asm/system.h>
122#include <asm/uaccess.h>
123
124#include <linux/netfilter_arp.h>
125
126/*
127 * Interface to generic neighbour cache.
128 */
129static u32 arp_hash(const void *pkey, const struct net_device *dev);
130static int arp_constructor(struct neighbour *neigh);
131static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb);
132static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb);
133static void parp_redo(struct sk_buff *skb);
134
135static struct neigh_ops arp_generic_ops = {
136 .family = AF_INET,
137 .solicit = arp_solicit,
138 .error_report = arp_error_report,
139 .output = neigh_resolve_output,
140 .connected_output = neigh_connected_output,
141 .hh_output = dev_queue_xmit,
142 .queue_xmit = dev_queue_xmit,
143};
144
145static struct neigh_ops arp_hh_ops = {
146 .family = AF_INET,
147 .solicit = arp_solicit,
148 .error_report = arp_error_report,
149 .output = neigh_resolve_output,
150 .connected_output = neigh_resolve_output,
151 .hh_output = dev_queue_xmit,
152 .queue_xmit = dev_queue_xmit,
153};
154
155static struct neigh_ops arp_direct_ops = {
156 .family = AF_INET,
157 .output = dev_queue_xmit,
158 .connected_output = dev_queue_xmit,
159 .hh_output = dev_queue_xmit,
160 .queue_xmit = dev_queue_xmit,
161};
162
163struct neigh_ops arp_broken_ops = {
164 .family = AF_INET,
165 .solicit = arp_solicit,
166 .error_report = arp_error_report,
167 .output = neigh_compat_output,
168 .connected_output = neigh_compat_output,
169 .hh_output = dev_queue_xmit,
170 .queue_xmit = dev_queue_xmit,
171};
172
173struct neigh_table arp_tbl = {
174 .family = AF_INET,
175 .entry_size = sizeof(struct neighbour) + 4,
176 .key_len = 4,
177 .hash = arp_hash,
178 .constructor = arp_constructor,
179 .proxy_redo = parp_redo,
180 .id = "arp_cache",
181 .parms = {
182 .tbl = &arp_tbl,
183 .base_reachable_time = 30 * HZ,
184 .retrans_time = 1 * HZ,
185 .gc_staletime = 60 * HZ,
186 .reachable_time = 30 * HZ,
187 .delay_probe_time = 5 * HZ,
188 .queue_len = 3,
189 .ucast_probes = 3,
190 .mcast_probes = 3,
191 .anycast_delay = 1 * HZ,
192 .proxy_delay = (8 * HZ) / 10,
193 .proxy_qlen = 64,
194 .locktime = 1 * HZ,
195 },
196 .gc_interval = 30 * HZ,
197 .gc_thresh1 = 128,
198 .gc_thresh2 = 512,
199 .gc_thresh3 = 1024,
200};
201
Al Viro714e85b2006-11-14 20:51:49 -0800202int arp_mc_map(__be32 addr, u8 *haddr, struct net_device *dev, int dir)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203{
204 switch (dev->type) {
205 case ARPHRD_ETHER:
206 case ARPHRD_FDDI:
207 case ARPHRD_IEEE802:
208 ip_eth_mc_map(addr, haddr);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900209 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 case ARPHRD_IEEE802_TR:
211 ip_tr_mc_map(addr, haddr);
212 return 0;
213 case ARPHRD_INFINIBAND:
214 ip_ib_mc_map(addr, haddr);
215 return 0;
216 default:
217 if (dir) {
218 memcpy(haddr, dev->broadcast, dev->addr_len);
219 return 0;
220 }
221 }
222 return -EINVAL;
223}
224
225
226static u32 arp_hash(const void *pkey, const struct net_device *dev)
227{
228 return jhash_2words(*(u32 *)pkey, dev->ifindex, arp_tbl.hash_rnd);
229}
230
231static int arp_constructor(struct neighbour *neigh)
232{
Al Virofd683222006-09-26 22:17:51 -0700233 __be32 addr = *(__be32*)neigh->primary_key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 struct net_device *dev = neigh->dev;
235 struct in_device *in_dev;
236 struct neigh_parms *parms;
237
238 neigh->type = inet_addr_type(addr);
239
240 rcu_read_lock();
Herbert Xue5ed6392005-10-03 14:35:55 -0700241 in_dev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 if (in_dev == NULL) {
243 rcu_read_unlock();
244 return -EINVAL;
245 }
246
247 parms = in_dev->arp_parms;
248 __neigh_parms_put(neigh->parms);
249 neigh->parms = neigh_parms_clone(parms);
250 rcu_read_unlock();
251
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700252 if (!dev->header_ops) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 neigh->nud_state = NUD_NOARP;
254 neigh->ops = &arp_direct_ops;
255 neigh->output = neigh->ops->queue_xmit;
256 } else {
257 /* Good devices (checked by reading texts, but only Ethernet is
258 tested)
259
260 ARPHRD_ETHER: (ethernet, apfddi)
261 ARPHRD_FDDI: (fddi)
262 ARPHRD_IEEE802: (tr)
263 ARPHRD_METRICOM: (strip)
264 ARPHRD_ARCNET:
265 etc. etc. etc.
266
267 ARPHRD_IPDDP will also work, if author repairs it.
268 I did not it, because this driver does not work even
269 in old paradigm.
270 */
271
272#if 1
273 /* So... these "amateur" devices are hopeless.
274 The only thing, that I can say now:
275 It is very sad that we need to keep ugly obsolete
276 code to make them happy.
277
278 They should be moved to more reasonable state, now
279 they use rebuild_header INSTEAD OF hard_start_xmit!!!
280 Besides that, they are sort of out of date
281 (a lot of redundant clones/copies, useless in 2.1),
282 I wonder why people believe that they work.
283 */
284 switch (dev->type) {
285 default:
286 break;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900287 case ARPHRD_ROSE:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
289 case ARPHRD_AX25:
290#if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
291 case ARPHRD_NETROM:
292#endif
293 neigh->ops = &arp_broken_ops;
294 neigh->output = neigh->ops->output;
295 return 0;
296#endif
297 ;}
298#endif
299 if (neigh->type == RTN_MULTICAST) {
300 neigh->nud_state = NUD_NOARP;
301 arp_mc_map(addr, neigh->ha, dev, 1);
302 } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
303 neigh->nud_state = NUD_NOARP;
304 memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
305 } else if (neigh->type == RTN_BROADCAST || dev->flags&IFF_POINTOPOINT) {
306 neigh->nud_state = NUD_NOARP;
307 memcpy(neigh->ha, dev->broadcast, dev->addr_len);
308 }
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700309
310 if (dev->header_ops->cache)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 neigh->ops = &arp_hh_ops;
312 else
313 neigh->ops = &arp_generic_ops;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700314
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 if (neigh->nud_state&NUD_VALID)
316 neigh->output = neigh->ops->connected_output;
317 else
318 neigh->output = neigh->ops->output;
319 }
320 return 0;
321}
322
323static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb)
324{
325 dst_link_failure(skb);
326 kfree_skb(skb);
327}
328
329static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb)
330{
Al Viroa61ced52006-09-26 21:27:54 -0700331 __be32 saddr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 u8 *dst_ha = NULL;
333 struct net_device *dev = neigh->dev;
Al Viroa61ced52006-09-26 21:27:54 -0700334 __be32 target = *(__be32*)neigh->primary_key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 int probes = atomic_read(&neigh->probes);
336 struct in_device *in_dev = in_dev_get(dev);
337
338 if (!in_dev)
339 return;
340
341 switch (IN_DEV_ARP_ANNOUNCE(in_dev)) {
342 default:
343 case 0: /* By default announce any local IP */
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700344 if (skb && inet_addr_type(ip_hdr(skb)->saddr) == RTN_LOCAL)
345 saddr = ip_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 break;
347 case 1: /* Restrict announcements of saddr in same subnet */
348 if (!skb)
349 break;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700350 saddr = ip_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 if (inet_addr_type(saddr) == RTN_LOCAL) {
352 /* saddr should be known to target */
353 if (inet_addr_onlink(in_dev, target, saddr))
354 break;
355 }
356 saddr = 0;
357 break;
358 case 2: /* Avoid secondary IPs, get a primary/preferred one */
359 break;
360 }
361
362 if (in_dev)
363 in_dev_put(in_dev);
364 if (!saddr)
365 saddr = inet_select_addr(dev, target, RT_SCOPE_LINK);
366
367 if ((probes -= neigh->parms->ucast_probes) < 0) {
368 if (!(neigh->nud_state&NUD_VALID))
369 printk(KERN_DEBUG "trying to ucast probe in NUD_INVALID\n");
370 dst_ha = neigh->ha;
371 read_lock_bh(&neigh->lock);
372 } else if ((probes -= neigh->parms->app_probes) < 0) {
373#ifdef CONFIG_ARPD
374 neigh_app_ns(neigh);
375#endif
376 return;
377 }
378
379 arp_send(ARPOP_REQUEST, ETH_P_ARP, target, dev, saddr,
380 dst_ha, dev->dev_addr, NULL);
381 if (dst_ha)
382 read_unlock_bh(&neigh->lock);
383}
384
385static int arp_ignore(struct in_device *in_dev, struct net_device *dev,
Al Viroed9bad02006-09-27 18:36:36 -0700386 __be32 sip, __be32 tip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387{
388 int scope;
389
390 switch (IN_DEV_ARP_IGNORE(in_dev)) {
391 case 0: /* Reply, the tip is already validated */
392 return 0;
393 case 1: /* Reply only if tip is configured on the incoming interface */
394 sip = 0;
395 scope = RT_SCOPE_HOST;
396 break;
397 case 2: /*
398 * Reply only if tip is configured on the incoming interface
399 * and is in same subnet as sip
400 */
401 scope = RT_SCOPE_HOST;
402 break;
403 case 3: /* Do not reply for scope host addresses */
404 sip = 0;
405 scope = RT_SCOPE_LINK;
406 dev = NULL;
407 break;
408 case 4: /* Reserved */
409 case 5:
410 case 6:
411 case 7:
412 return 0;
413 case 8: /* Do not reply */
414 return 1;
415 default:
416 return 0;
417 }
418 return !inet_confirm_addr(dev, sip, tip, scope);
419}
420
Al Viroed9bad02006-09-27 18:36:36 -0700421static int arp_filter(__be32 sip, __be32 tip, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422{
423 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = sip,
424 .saddr = tip } } };
425 struct rtable *rt;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900426 int flag = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 /*unsigned long now; */
428
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900429 if (ip_route_output_key(&rt, &fl) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 return 1;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900431 if (rt->u.dst.dev != dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 NET_INC_STATS_BH(LINUX_MIB_ARPFILTER);
433 flag = 1;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900434 }
435 ip_rt_put(rt);
436 return flag;
437}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438
439/* OBSOLETE FUNCTIONS */
440
441/*
442 * Find an arp mapping in the cache. If not found, post a request.
443 *
444 * It is very UGLY routine: it DOES NOT use skb->dst->neighbour,
445 * even if it exists. It is supposed that skb->dev was mangled
446 * by a virtual device (eql, shaper). Nobody but broken devices
447 * is allowed to use this function, it is scheduled to be removed. --ANK
448 */
449
Al Viroed9bad02006-09-27 18:36:36 -0700450static int arp_set_predefined(int addr_hint, unsigned char * haddr, __be32 paddr, struct net_device * dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451{
452 switch (addr_hint) {
453 case RTN_LOCAL:
454 printk(KERN_DEBUG "ARP: arp called for own IP address\n");
455 memcpy(haddr, dev->dev_addr, dev->addr_len);
456 return 1;
457 case RTN_MULTICAST:
458 arp_mc_map(paddr, haddr, dev, 1);
459 return 1;
460 case RTN_BROADCAST:
461 memcpy(haddr, dev->broadcast, dev->addr_len);
462 return 1;
463 }
464 return 0;
465}
466
467
468int arp_find(unsigned char *haddr, struct sk_buff *skb)
469{
470 struct net_device *dev = skb->dev;
Al Virofd683222006-09-26 22:17:51 -0700471 __be32 paddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 struct neighbour *n;
473
474 if (!skb->dst) {
475 printk(KERN_DEBUG "arp_find is called with dst==NULL\n");
476 kfree_skb(skb);
477 return 1;
478 }
479
480 paddr = ((struct rtable*)skb->dst)->rt_gateway;
481
482 if (arp_set_predefined(inet_addr_type(paddr), haddr, paddr, dev))
483 return 0;
484
485 n = __neigh_lookup(&arp_tbl, &paddr, dev, 1);
486
487 if (n) {
488 n->used = jiffies;
489 if (n->nud_state&NUD_VALID || neigh_event_send(n, skb) == 0) {
490 read_lock_bh(&n->lock);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900491 memcpy(haddr, n->ha, dev->addr_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 read_unlock_bh(&n->lock);
493 neigh_release(n);
494 return 0;
495 }
496 neigh_release(n);
497 } else
498 kfree_skb(skb);
499 return 1;
500}
501
502/* END OF OBSOLETE FUNCTIONS */
503
504int arp_bind_neighbour(struct dst_entry *dst)
505{
506 struct net_device *dev = dst->dev;
507 struct neighbour *n = dst->neighbour;
508
509 if (dev == NULL)
510 return -EINVAL;
511 if (n == NULL) {
Al Viroed9bad02006-09-27 18:36:36 -0700512 __be32 nexthop = ((struct rtable*)dst)->rt_gateway;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 if (dev->flags&(IFF_LOOPBACK|IFF_POINTOPOINT))
514 nexthop = 0;
515 n = __neigh_lookup_errno(
516#if defined(CONFIG_ATM_CLIP) || defined(CONFIG_ATM_CLIP_MODULE)
517 dev->type == ARPHRD_ATM ? clip_tbl_hook :
518#endif
519 &arp_tbl, &nexthop, dev);
520 if (IS_ERR(n))
521 return PTR_ERR(n);
522 dst->neighbour = n;
523 }
524 return 0;
525}
526
527/*
528 * Check if we can use proxy ARP for this path
529 */
530
531static inline int arp_fwd_proxy(struct in_device *in_dev, struct rtable *rt)
532{
533 struct in_device *out_dev;
534 int imi, omi = -1;
535
536 if (!IN_DEV_PROXY_ARP(in_dev))
537 return 0;
538
539 if ((imi = IN_DEV_MEDIUM_ID(in_dev)) == 0)
540 return 1;
541 if (imi == -1)
542 return 0;
543
544 /* place to check for proxy_arp for routes */
545
546 if ((out_dev = in_dev_get(rt->u.dst.dev)) != NULL) {
547 omi = IN_DEV_MEDIUM_ID(out_dev);
548 in_dev_put(out_dev);
549 }
550 return (omi != imi && omi != -1);
551}
552
553/*
554 * Interface to link layer: send routine and receive handler.
555 */
556
557/*
558 * Create an arp packet. If (dest_hw == NULL), we create a broadcast
559 * message.
560 */
Al Viroed9bad02006-09-27 18:36:36 -0700561struct sk_buff *arp_create(int type, int ptype, __be32 dest_ip,
562 struct net_device *dev, __be32 src_ip,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 unsigned char *dest_hw, unsigned char *src_hw,
564 unsigned char *target_hw)
565{
566 struct sk_buff *skb;
567 struct arphdr *arp;
568 unsigned char *arp_ptr;
569
570 /*
571 * Allocate a buffer
572 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900573
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 skb = alloc_skb(sizeof(struct arphdr)+ 2*(dev->addr_len+4)
575 + LL_RESERVED_SPACE(dev), GFP_ATOMIC);
576 if (skb == NULL)
577 return NULL;
578
579 skb_reserve(skb, LL_RESERVED_SPACE(dev));
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -0700580 skb_reset_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 arp = (struct arphdr *) skb_put(skb,sizeof(struct arphdr) + 2*(dev->addr_len+4));
582 skb->dev = dev;
583 skb->protocol = htons(ETH_P_ARP);
584 if (src_hw == NULL)
585 src_hw = dev->dev_addr;
586 if (dest_hw == NULL)
587 dest_hw = dev->broadcast;
588
589 /*
590 * Fill the device header for the ARP frame
591 */
Stephen Hemminger0c4e8582007-10-09 01:36:32 -0700592 if (dev_hard_header(skb, dev, ptype, dest_hw, src_hw, skb->len) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 goto out;
594
595 /*
596 * Fill out the arp protocol part.
597 *
598 * The arp hardware type should match the device type, except for FDDI,
599 * which (according to RFC 1390) should always equal 1 (Ethernet).
600 */
601 /*
602 * Exceptions everywhere. AX.25 uses the AX.25 PID value not the
603 * DIX code for the protocol. Make these device structure fields.
604 */
605 switch (dev->type) {
606 default:
607 arp->ar_hrd = htons(dev->type);
608 arp->ar_pro = htons(ETH_P_IP);
609 break;
610
611#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
612 case ARPHRD_AX25:
613 arp->ar_hrd = htons(ARPHRD_AX25);
614 arp->ar_pro = htons(AX25_P_IP);
615 break;
616
617#if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
618 case ARPHRD_NETROM:
619 arp->ar_hrd = htons(ARPHRD_NETROM);
620 arp->ar_pro = htons(AX25_P_IP);
621 break;
622#endif
623#endif
624
625#ifdef CONFIG_FDDI
626 case ARPHRD_FDDI:
627 arp->ar_hrd = htons(ARPHRD_ETHER);
628 arp->ar_pro = htons(ETH_P_IP);
629 break;
630#endif
631#ifdef CONFIG_TR
632 case ARPHRD_IEEE802_TR:
633 arp->ar_hrd = htons(ARPHRD_IEEE802);
634 arp->ar_pro = htons(ETH_P_IP);
635 break;
636#endif
637 }
638
639 arp->ar_hln = dev->addr_len;
640 arp->ar_pln = 4;
641 arp->ar_op = htons(type);
642
643 arp_ptr=(unsigned char *)(arp+1);
644
645 memcpy(arp_ptr, src_hw, dev->addr_len);
646 arp_ptr+=dev->addr_len;
647 memcpy(arp_ptr, &src_ip,4);
648 arp_ptr+=4;
649 if (target_hw != NULL)
650 memcpy(arp_ptr, target_hw, dev->addr_len);
651 else
652 memset(arp_ptr, 0, dev->addr_len);
653 arp_ptr+=dev->addr_len;
654 memcpy(arp_ptr, &dest_ip, 4);
655
656 return skb;
657
658out:
659 kfree_skb(skb);
660 return NULL;
661}
662
663/*
664 * Send an arp packet.
665 */
666void arp_xmit(struct sk_buff *skb)
667{
668 /* Send it off, maybe filter it using firewalling first. */
669 NF_HOOK(NF_ARP, NF_ARP_OUT, skb, NULL, skb->dev, dev_queue_xmit);
670}
671
672/*
673 * Create and send an arp packet.
674 */
Al Viroed9bad02006-09-27 18:36:36 -0700675void arp_send(int type, int ptype, __be32 dest_ip,
676 struct net_device *dev, __be32 src_ip,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 unsigned char *dest_hw, unsigned char *src_hw,
678 unsigned char *target_hw)
679{
680 struct sk_buff *skb;
681
682 /*
683 * No arp on this interface.
684 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900685
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 if (dev->flags&IFF_NOARP)
687 return;
688
689 skb = arp_create(type, ptype, dest_ip, dev, src_ip,
690 dest_hw, src_hw, target_hw);
691 if (skb == NULL) {
692 return;
693 }
694
695 arp_xmit(skb);
696}
697
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698/*
699 * Process an arp request.
700 */
701
702static int arp_process(struct sk_buff *skb)
703{
704 struct net_device *dev = skb->dev;
705 struct in_device *in_dev = in_dev_get(dev);
706 struct arphdr *arp;
707 unsigned char *arp_ptr;
708 struct rtable *rt;
Mark Rydene0260fe2007-12-19 23:38:11 -0800709 unsigned char *sha;
Al Viro9e12bb22006-09-26 21:25:20 -0700710 __be32 sip, tip;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 u16 dev_type = dev->type;
712 int addr_type;
713 struct neighbour *n;
714
715 /* arp_rcv below verifies the ARP header and verifies the device
716 * is ARP'able.
717 */
718
719 if (in_dev == NULL)
720 goto out;
721
Arnaldo Carvalho de Melod0a92be2007-03-12 20:56:31 -0300722 arp = arp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723
724 switch (dev_type) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900725 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 if (arp->ar_pro != htons(ETH_P_IP) ||
727 htons(dev_type) != arp->ar_hrd)
728 goto out;
729 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 case ARPHRD_ETHER:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 case ARPHRD_IEEE802_TR:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 case ARPHRD_FDDI:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 case ARPHRD_IEEE802:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 /*
735 * ETHERNET, Token Ring and Fibre Channel (which are IEEE 802
736 * devices, according to RFC 2625) devices will accept ARP
737 * hardware types of either 1 (Ethernet) or 6 (IEEE 802.2).
738 * This is the case also of FDDI, where the RFC 1390 says that
739 * FDDI devices should accept ARP hardware of (1) Ethernet,
740 * however, to be more robust, we'll accept both 1 (Ethernet)
741 * or 6 (IEEE 802.2)
742 */
743 if ((arp->ar_hrd != htons(ARPHRD_ETHER) &&
744 arp->ar_hrd != htons(ARPHRD_IEEE802)) ||
745 arp->ar_pro != htons(ETH_P_IP))
746 goto out;
747 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 case ARPHRD_AX25:
749 if (arp->ar_pro != htons(AX25_P_IP) ||
750 arp->ar_hrd != htons(ARPHRD_AX25))
751 goto out;
752 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 case ARPHRD_NETROM:
754 if (arp->ar_pro != htons(AX25_P_IP) ||
755 arp->ar_hrd != htons(ARPHRD_NETROM))
756 goto out;
757 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 }
759
760 /* Understand only these message types */
761
762 if (arp->ar_op != htons(ARPOP_REPLY) &&
763 arp->ar_op != htons(ARPOP_REQUEST))
764 goto out;
765
766/*
767 * Extract fields
768 */
769 arp_ptr= (unsigned char *)(arp+1);
770 sha = arp_ptr;
771 arp_ptr += dev->addr_len;
772 memcpy(&sip, arp_ptr, 4);
773 arp_ptr += 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 arp_ptr += dev->addr_len;
775 memcpy(&tip, arp_ptr, 4);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900776/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 * Check for bad requests for 127.x.x.x and requests for multicast
778 * addresses. If this is one such, delete it.
779 */
780 if (LOOPBACK(tip) || MULTICAST(tip))
781 goto out;
782
783/*
784 * Special case: We must set Frame Relay source Q.922 address
785 */
786 if (dev_type == ARPHRD_DLCI)
787 sha = dev->broadcast;
788
789/*
790 * Process entry. The idea here is we want to send a reply if it is a
791 * request for us or if it is a request for someone else that we hold
792 * a proxy for. We want to add an entry to our cache if it is a reply
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900793 * to us or if it is a request for our address.
794 * (The assumption for this last is that if someone is requesting our
795 * address, they are probably intending to talk to us, so it saves time
796 * if we cache their address. Their address is also probably not in
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 * our cache, since ours is not in their cache.)
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900798 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 * Putting this another way, we only care about replies if they are to
800 * us, in which case we add them to the cache. For requests, we care
801 * about those for us and those for our proxies. We reply to both,
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900802 * and in the case of requests for us we add the requester to the arp
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 * cache.
804 */
805
806 /* Special case: IPv4 duplicate address detection packet (RFC2131) */
807 if (sip == 0) {
808 if (arp->ar_op == htons(ARPOP_REQUEST) &&
809 inet_addr_type(tip) == RTN_LOCAL &&
810 !arp_ignore(in_dev,dev,sip,tip))
Jonas Danielssonb4a98112007-11-20 17:38:16 -0800811 arp_send(ARPOP_REPLY, ETH_P_ARP, sip, dev, tip, sha,
812 dev->dev_addr, sha);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 goto out;
814 }
815
816 if (arp->ar_op == htons(ARPOP_REQUEST) &&
817 ip_route_input(skb, tip, sip, 0, dev) == 0) {
818
819 rt = (struct rtable*)skb->dst;
820 addr_type = rt->rt_type;
821
822 if (addr_type == RTN_LOCAL) {
823 n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
824 if (n) {
825 int dont_send = 0;
826
827 if (!dont_send)
828 dont_send |= arp_ignore(in_dev,dev,sip,tip);
829 if (!dont_send && IN_DEV_ARPFILTER(in_dev))
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900830 dont_send |= arp_filter(sip,tip,dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 if (!dont_send)
832 arp_send(ARPOP_REPLY,ETH_P_ARP,sip,dev,tip,sha,dev->dev_addr,sha);
833
834 neigh_release(n);
835 }
836 goto out;
837 } else if (IN_DEV_FORWARD(in_dev)) {
838 if ((rt->rt_flags&RTCF_DNAT) ||
839 (addr_type == RTN_UNICAST && rt->u.dst.dev != dev &&
840 (arp_fwd_proxy(in_dev, rt) || pneigh_lookup(&arp_tbl, &tip, dev, 0)))) {
841 n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
842 if (n)
843 neigh_release(n);
844
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900845 if (NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 skb->pkt_type == PACKET_HOST ||
847 in_dev->arp_parms->proxy_delay == 0) {
848 arp_send(ARPOP_REPLY,ETH_P_ARP,sip,dev,tip,sha,dev->dev_addr,sha);
849 } else {
850 pneigh_enqueue(&arp_tbl, in_dev->arp_parms, skb);
851 in_dev_put(in_dev);
852 return 0;
853 }
854 goto out;
855 }
856 }
857 }
858
859 /* Update our ARP tables */
860
861 n = __neigh_lookup(&arp_tbl, &sip, dev, 0);
862
Herbert Xu42f811b2007-06-04 23:34:44 -0700863 if (IPV4_DEVCONF_ALL(ARP_ACCEPT)) {
Neil Hormanabd596a2006-03-20 22:39:47 -0800864 /* Unsolicited ARP is not accepted by default.
865 It is possible, that this option should be enabled for some
866 devices (strip is candidate)
867 */
868 if (n == NULL &&
869 arp->ar_op == htons(ARPOP_REPLY) &&
870 inet_addr_type(sip) == RTN_UNICAST)
Jean Delvare1b1ac752007-07-14 20:51:44 -0700871 n = __neigh_lookup(&arp_tbl, &sip, dev, 1);
Neil Hormanabd596a2006-03-20 22:39:47 -0800872 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873
874 if (n) {
875 int state = NUD_REACHABLE;
876 int override;
877
878 /* If several different ARP replies follows back-to-back,
879 use the FIRST one. It is possible, if several proxy
880 agents are active. Taking the first reply prevents
881 arp trashing and chooses the fastest router.
882 */
883 override = time_after(jiffies, n->updated + n->parms->locktime);
884
885 /* Broadcast replies and request packets
886 do not assert neighbour reachability.
887 */
888 if (arp->ar_op != htons(ARPOP_REPLY) ||
889 skb->pkt_type != PACKET_HOST)
890 state = NUD_STALE;
891 neigh_update(n, sha, state, override ? NEIGH_UPDATE_F_OVERRIDE : 0);
892 neigh_release(n);
893 }
894
895out:
896 if (in_dev)
897 in_dev_put(in_dev);
898 kfree_skb(skb);
899 return 0;
900}
901
Herbert Xu444fc8f2005-10-03 14:18:10 -0700902static void parp_redo(struct sk_buff *skb)
903{
904 arp_process(skb);
905}
906
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907
908/*
909 * Receive an arp request from the device layer.
910 */
911
Adrian Bunk6c97e722006-04-12 13:57:59 -0700912static int arp_rcv(struct sk_buff *skb, struct net_device *dev,
913 struct packet_type *pt, struct net_device *orig_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914{
915 struct arphdr *arp;
916
Eric W. Biedermane730c152007-09-17 11:53:39 -0700917 if (dev->nd_net != &init_net)
918 goto freeskb;
919
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 /* ARP header, plus 2 device addresses, plus 2 IP addresses. */
921 if (!pskb_may_pull(skb, (sizeof(struct arphdr) +
922 (2 * dev->addr_len) +
923 (2 * sizeof(u32)))))
924 goto freeskb;
925
Arnaldo Carvalho de Melod0a92be2007-03-12 20:56:31 -0300926 arp = arp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 if (arp->ar_hln != dev->addr_len ||
928 dev->flags & IFF_NOARP ||
929 skb->pkt_type == PACKET_OTHERHOST ||
930 skb->pkt_type == PACKET_LOOPBACK ||
931 arp->ar_pln != 4)
932 goto freeskb;
933
934 if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
935 goto out_of_mem;
936
Patrick McHardya61bbcf2005-08-14 17:24:31 -0700937 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
938
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 return NF_HOOK(NF_ARP, NF_ARP_IN, skb, dev, NULL, arp_process);
940
941freeskb:
942 kfree_skb(skb);
943out_of_mem:
944 return 0;
945}
946
947/*
948 * User level interface (ioctl)
949 */
950
951/*
952 * Set (create) an ARP cache entry.
953 */
954
955static int arp_req_set(struct arpreq *r, struct net_device * dev)
956{
Al Viroed9bad02006-09-27 18:36:36 -0700957 __be32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 struct neighbour *neigh;
959 int err;
960
961 if (r->arp_flags&ATF_PUBL) {
Al Viroed9bad02006-09-27 18:36:36 -0700962 __be32 mask = ((struct sockaddr_in *) &r->arp_netmask)->sin_addr.s_addr;
963 if (mask && mask != htonl(0xFFFFFFFF))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 return -EINVAL;
965 if (!dev && (r->arp_flags & ATF_COM)) {
Eric W. Biederman881d9662007-09-17 11:56:21 -0700966 dev = dev_getbyhwaddr(&init_net, r->arp_ha.sa_family, r->arp_ha.sa_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 if (!dev)
968 return -ENODEV;
969 }
970 if (mask) {
971 if (pneigh_lookup(&arp_tbl, &ip, dev, 1) == NULL)
972 return -ENOBUFS;
973 return 0;
974 }
975 if (dev == NULL) {
Herbert Xu42f811b2007-06-04 23:34:44 -0700976 IPV4_DEVCONF_ALL(PROXY_ARP) = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 return 0;
978 }
Herbert Xue5ed6392005-10-03 14:35:55 -0700979 if (__in_dev_get_rtnl(dev)) {
Herbert Xu42f811b2007-06-04 23:34:44 -0700980 IN_DEV_CONF_SET(__in_dev_get_rtnl(dev), PROXY_ARP, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 return 0;
982 }
983 return -ENXIO;
984 }
985
986 if (r->arp_flags & ATF_PERM)
987 r->arp_flags |= ATF_COM;
988 if (dev == NULL) {
989 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = ip,
990 .tos = RTO_ONLINK } } };
991 struct rtable * rt;
992 if ((err = ip_route_output_key(&rt, &fl)) != 0)
993 return err;
994 dev = rt->u.dst.dev;
995 ip_rt_put(rt);
996 if (!dev)
997 return -EINVAL;
998 }
999 switch (dev->type) {
1000#ifdef CONFIG_FDDI
1001 case ARPHRD_FDDI:
1002 /*
1003 * According to RFC 1390, FDDI devices should accept ARP
1004 * hardware types of 1 (Ethernet). However, to be more
1005 * robust, we'll accept hardware types of either 1 (Ethernet)
1006 * or 6 (IEEE 802.2).
1007 */
1008 if (r->arp_ha.sa_family != ARPHRD_FDDI &&
1009 r->arp_ha.sa_family != ARPHRD_ETHER &&
1010 r->arp_ha.sa_family != ARPHRD_IEEE802)
1011 return -EINVAL;
1012 break;
1013#endif
1014 default:
1015 if (r->arp_ha.sa_family != dev->type)
1016 return -EINVAL;
1017 break;
1018 }
1019
1020 neigh = __neigh_lookup_errno(&arp_tbl, &ip, dev);
1021 err = PTR_ERR(neigh);
1022 if (!IS_ERR(neigh)) {
1023 unsigned state = NUD_STALE;
1024 if (r->arp_flags & ATF_PERM)
1025 state = NUD_PERMANENT;
1026 err = neigh_update(neigh, (r->arp_flags&ATF_COM) ?
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001027 r->arp_ha.sa_data : NULL, state,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 NEIGH_UPDATE_F_OVERRIDE|
1029 NEIGH_UPDATE_F_ADMIN);
1030 neigh_release(neigh);
1031 }
1032 return err;
1033}
1034
1035static unsigned arp_state_to_flags(struct neighbour *neigh)
1036{
1037 unsigned flags = 0;
1038 if (neigh->nud_state&NUD_PERMANENT)
1039 flags = ATF_PERM|ATF_COM;
1040 else if (neigh->nud_state&NUD_VALID)
1041 flags = ATF_COM;
1042 return flags;
1043}
1044
1045/*
1046 * Get an ARP cache entry.
1047 */
1048
1049static int arp_req_get(struct arpreq *r, struct net_device *dev)
1050{
Al Viroed9bad02006-09-27 18:36:36 -07001051 __be32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 struct neighbour *neigh;
1053 int err = -ENXIO;
1054
1055 neigh = neigh_lookup(&arp_tbl, &ip, dev);
1056 if (neigh) {
1057 read_lock_bh(&neigh->lock);
1058 memcpy(r->arp_ha.sa_data, neigh->ha, dev->addr_len);
1059 r->arp_flags = arp_state_to_flags(neigh);
1060 read_unlock_bh(&neigh->lock);
1061 r->arp_ha.sa_family = dev->type;
1062 strlcpy(r->arp_dev, dev->name, sizeof(r->arp_dev));
1063 neigh_release(neigh);
1064 err = 0;
1065 }
1066 return err;
1067}
1068
1069static int arp_req_delete(struct arpreq *r, struct net_device * dev)
1070{
1071 int err;
Al Viroed9bad02006-09-27 18:36:36 -07001072 __be32 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 struct neighbour *neigh;
1074
1075 if (r->arp_flags & ATF_PUBL) {
Al Viroed9bad02006-09-27 18:36:36 -07001076 __be32 mask =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr;
Al Viroed9bad02006-09-27 18:36:36 -07001078 if (mask == htonl(0xFFFFFFFF))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 return pneigh_delete(&arp_tbl, &ip, dev);
1080 if (mask == 0) {
1081 if (dev == NULL) {
Herbert Xu42f811b2007-06-04 23:34:44 -07001082 IPV4_DEVCONF_ALL(PROXY_ARP) = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 return 0;
1084 }
Herbert Xue5ed6392005-10-03 14:35:55 -07001085 if (__in_dev_get_rtnl(dev)) {
Herbert Xu42f811b2007-06-04 23:34:44 -07001086 IN_DEV_CONF_SET(__in_dev_get_rtnl(dev),
1087 PROXY_ARP, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 return 0;
1089 }
1090 return -ENXIO;
1091 }
1092 return -EINVAL;
1093 }
1094
1095 if (dev == NULL) {
1096 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = ip,
1097 .tos = RTO_ONLINK } } };
1098 struct rtable * rt;
1099 if ((err = ip_route_output_key(&rt, &fl)) != 0)
1100 return err;
1101 dev = rt->u.dst.dev;
1102 ip_rt_put(rt);
1103 if (!dev)
1104 return -EINVAL;
1105 }
1106 err = -ENXIO;
1107 neigh = neigh_lookup(&arp_tbl, &ip, dev);
1108 if (neigh) {
1109 if (neigh->nud_state&~NUD_NOARP)
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001110 err = neigh_update(neigh, NULL, NUD_FAILED,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 NEIGH_UPDATE_F_OVERRIDE|
1112 NEIGH_UPDATE_F_ADMIN);
1113 neigh_release(neigh);
1114 }
1115 return err;
1116}
1117
1118/*
1119 * Handle an ARP layer I/O control request.
1120 */
1121
1122int arp_ioctl(unsigned int cmd, void __user *arg)
1123{
1124 int err;
1125 struct arpreq r;
1126 struct net_device *dev = NULL;
1127
1128 switch (cmd) {
1129 case SIOCDARP:
1130 case SIOCSARP:
1131 if (!capable(CAP_NET_ADMIN))
1132 return -EPERM;
1133 case SIOCGARP:
1134 err = copy_from_user(&r, arg, sizeof(struct arpreq));
1135 if (err)
1136 return -EFAULT;
1137 break;
1138 default:
1139 return -EINVAL;
1140 }
1141
1142 if (r.arp_pa.sa_family != AF_INET)
1143 return -EPFNOSUPPORT;
1144
1145 if (!(r.arp_flags & ATF_PUBL) &&
1146 (r.arp_flags & (ATF_NETMASK|ATF_DONTPUB)))
1147 return -EINVAL;
1148 if (!(r.arp_flags & ATF_NETMASK))
1149 ((struct sockaddr_in *)&r.arp_netmask)->sin_addr.s_addr =
1150 htonl(0xFFFFFFFFUL);
1151 rtnl_lock();
1152 if (r.arp_dev[0]) {
1153 err = -ENODEV;
Eric W. Biederman881d9662007-09-17 11:56:21 -07001154 if ((dev = __dev_get_by_name(&init_net, r.arp_dev)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 goto out;
1156
1157 /* Mmmm... It is wrong... ARPHRD_NETROM==0 */
1158 if (!r.arp_ha.sa_family)
1159 r.arp_ha.sa_family = dev->type;
1160 err = -EINVAL;
1161 if ((r.arp_flags & ATF_COM) && r.arp_ha.sa_family != dev->type)
1162 goto out;
1163 } else if (cmd == SIOCGARP) {
1164 err = -ENODEV;
1165 goto out;
1166 }
1167
Stephen Hemminger132adf52007-03-08 20:44:43 -08001168 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 case SIOCDARP:
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001170 err = arp_req_delete(&r, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 break;
1172 case SIOCSARP:
1173 err = arp_req_set(&r, dev);
1174 break;
1175 case SIOCGARP:
1176 err = arp_req_get(&r, dev);
1177 if (!err && copy_to_user(arg, &r, sizeof(r)))
1178 err = -EFAULT;
1179 break;
1180 }
1181out:
1182 rtnl_unlock();
1183 return err;
1184}
1185
1186static int arp_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1187{
1188 struct net_device *dev = ptr;
1189
Eric W. Biedermane9dc8652007-09-12 13:02:17 +02001190 if (dev->nd_net != &init_net)
1191 return NOTIFY_DONE;
1192
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 switch (event) {
1194 case NETDEV_CHANGEADDR:
1195 neigh_changeaddr(&arp_tbl, dev);
1196 rt_cache_flush(0);
1197 break;
1198 default:
1199 break;
1200 }
1201
1202 return NOTIFY_DONE;
1203}
1204
1205static struct notifier_block arp_netdev_notifier = {
1206 .notifier_call = arp_netdev_event,
1207};
1208
1209/* Note, that it is not on notifier chain.
1210 It is necessary, that this routine was called after route cache will be
1211 flushed.
1212 */
1213void arp_ifdown(struct net_device *dev)
1214{
1215 neigh_ifdown(&arp_tbl, dev);
1216}
1217
1218
1219/*
1220 * Called once on startup.
1221 */
1222
1223static struct packet_type arp_packet_type = {
1224 .type = __constant_htons(ETH_P_ARP),
1225 .func = arp_rcv,
1226};
1227
1228static int arp_proc_init(void);
1229
1230void __init arp_init(void)
1231{
1232 neigh_table_init(&arp_tbl);
1233
1234 dev_add_pack(&arp_packet_type);
1235 arp_proc_init();
1236#ifdef CONFIG_SYSCTL
1237 neigh_sysctl_register(NULL, &arp_tbl.parms, NET_IPV4,
1238 NET_IPV4_NEIGH, "ipv4", NULL, NULL);
1239#endif
1240 register_netdevice_notifier(&arp_netdev_notifier);
1241}
1242
1243#ifdef CONFIG_PROC_FS
1244#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1245
1246/* ------------------------------------------------------------------------ */
1247/*
1248 * ax25 -> ASCII conversion
1249 */
1250static char *ax2asc2(ax25_address *a, char *buf)
1251{
1252 char c, *s;
1253 int n;
1254
1255 for (n = 0, s = buf; n < 6; n++) {
1256 c = (a->ax25_call[n] >> 1) & 0x7F;
1257
1258 if (c != ' ') *s++ = c;
1259 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001260
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261 *s++ = '-';
1262
1263 if ((n = ((a->ax25_call[6] >> 1) & 0x0F)) > 9) {
1264 *s++ = '1';
1265 n -= 10;
1266 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001267
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 *s++ = n + '0';
1269 *s++ = '\0';
1270
1271 if (*buf == '\0' || *buf == '-')
1272 return "*";
1273
1274 return buf;
1275
1276}
1277#endif /* CONFIG_AX25 */
1278
1279#define HBUFFERLEN 30
1280
1281static void arp_format_neigh_entry(struct seq_file *seq,
1282 struct neighbour *n)
1283{
1284 char hbuffer[HBUFFERLEN];
1285 const char hexbuf[] = "0123456789ABCDEF";
1286 int k, j;
1287 char tbuf[16];
1288 struct net_device *dev = n->dev;
1289 int hatype = dev->type;
1290
1291 read_lock(&n->lock);
1292 /* Convert hardware address to XX:XX:XX:XX ... form. */
1293#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1294 if (hatype == ARPHRD_AX25 || hatype == ARPHRD_NETROM)
1295 ax2asc2((ax25_address *)n->ha, hbuffer);
1296 else {
1297#endif
1298 for (k = 0, j = 0; k < HBUFFERLEN - 3 && j < dev->addr_len; j++) {
1299 hbuffer[k++] = hexbuf[(n->ha[j] >> 4) & 15];
1300 hbuffer[k++] = hexbuf[n->ha[j] & 15];
1301 hbuffer[k++] = ':';
1302 }
1303 hbuffer[--k] = 0;
1304#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1305 }
1306#endif
1307 sprintf(tbuf, "%u.%u.%u.%u", NIPQUAD(*(u32*)n->primary_key));
1308 seq_printf(seq, "%-16s 0x%-10x0x%-10x%s * %s\n",
1309 tbuf, hatype, arp_state_to_flags(n), hbuffer, dev->name);
1310 read_unlock(&n->lock);
1311}
1312
1313static void arp_format_pneigh_entry(struct seq_file *seq,
1314 struct pneigh_entry *n)
1315{
1316 struct net_device *dev = n->dev;
1317 int hatype = dev ? dev->type : 0;
1318 char tbuf[16];
1319
1320 sprintf(tbuf, "%u.%u.%u.%u", NIPQUAD(*(u32*)n->key));
1321 seq_printf(seq, "%-16s 0x%-10x0x%-10x%s * %s\n",
1322 tbuf, hatype, ATF_PUBL | ATF_PERM, "00:00:00:00:00:00",
1323 dev ? dev->name : "*");
1324}
1325
1326static int arp_seq_show(struct seq_file *seq, void *v)
1327{
1328 if (v == SEQ_START_TOKEN) {
1329 seq_puts(seq, "IP address HW type Flags "
1330 "HW address Mask Device\n");
1331 } else {
1332 struct neigh_seq_state *state = seq->private;
1333
1334 if (state->flags & NEIGH_SEQ_IS_PNEIGH)
1335 arp_format_pneigh_entry(seq, v);
1336 else
1337 arp_format_neigh_entry(seq, v);
1338 }
1339
1340 return 0;
1341}
1342
1343static void *arp_seq_start(struct seq_file *seq, loff_t *pos)
1344{
1345 /* Don't want to confuse "arp -a" w/ magic entries,
1346 * so we tell the generic iterator to skip NUD_NOARP.
1347 */
1348 return neigh_seq_start(seq, pos, &arp_tbl, NEIGH_SEQ_SKIP_NOARP);
1349}
1350
1351/* ------------------------------------------------------------------------ */
1352
Stephen Hemmingerf6908082007-03-12 14:34:29 -07001353static const struct seq_operations arp_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354 .start = arp_seq_start,
1355 .next = neigh_seq_next,
1356 .stop = neigh_seq_stop,
1357 .show = arp_seq_show,
1358};
1359
1360static int arp_seq_open(struct inode *inode, struct file *file)
1361{
Pavel Emelyanovcf7732e2007-10-10 02:29:29 -07001362 return seq_open_private(file, &arp_seq_ops,
1363 sizeof(struct neigh_seq_state));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364}
1365
Arjan van de Ven9a321442007-02-12 00:55:35 -08001366static const struct file_operations arp_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 .owner = THIS_MODULE,
1368 .open = arp_seq_open,
1369 .read = seq_read,
1370 .llseek = seq_lseek,
1371 .release = seq_release_private,
1372};
1373
1374static int __init arp_proc_init(void)
1375{
Eric W. Biederman457c4cb2007-09-12 12:01:34 +02001376 if (!proc_net_fops_create(&init_net, "arp", S_IRUGO, &arp_seq_fops))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 return -ENOMEM;
1378 return 0;
1379}
1380
1381#else /* CONFIG_PROC_FS */
1382
1383static int __init arp_proc_init(void)
1384{
1385 return 0;
1386}
1387
1388#endif /* CONFIG_PROC_FS */
1389
1390EXPORT_SYMBOL(arp_broken_ops);
1391EXPORT_SYMBOL(arp_find);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392EXPORT_SYMBOL(arp_create);
1393EXPORT_SYMBOL(arp_xmit);
1394EXPORT_SYMBOL(arp_send);
1395EXPORT_SYMBOL(arp_tbl);
1396
1397#if defined(CONFIG_ATM_CLIP) || defined(CONFIG_ATM_CLIP_MODULE)
1398EXPORT_SYMBOL(clip_tbl_hook);
1399#endif