xref: /openbmc/linux/net/ipv4/arp.c (revision b04b4f78)
1 /* linux/net/ipv4/arp.c
2  *
3  * 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:
16  *		Alan Cox	:	Removed the Ethernet assumptions in
17  *					Florian's code
18  *		Alan Cox	:	Fixed some small errors in the ARP
19  *					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.
40  *		Craig Schlenter :	Don't modify permanent entry
41  *					during arp_rcv.
42  *		Russ Nelson	:	Tidied up a few bits.
43  *		Alexey Kuznetsov:	Major changes to caching and behaviour,
44  *					eg intelligent arp probing and
45  *					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.
51  *              Jonathan Layes  :       Added arpd support through kerneld
52  *                                      message queue (960314)
53  *		Mike Shaver	:	/proc/sys/net/ipv4/arp_* support
54  *		Mike McLagan    :	Routing by source
55  *		Stuart Cheshire	:	Metricom and grat arp fixes
56  *					*** FOR 2.1 clean this up ***
57  *		Lawrence V. Stefani: (08/12/96) Added FDDI support.
58  *		Alan Cox 	:	Took the AP1000 nasty FDDI hack and
59  *					folded into the mainstream FDDI code.
60  *					Ack spit, Linus how did you allow that
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
73  */
74 
75 #include <linux/module.h>
76 #include <linux/types.h>
77 #include <linux/string.h>
78 #include <linux/kernel.h>
79 #include <linux/capability.h>
80 #include <linux/socket.h>
81 #include <linux/sockios.h>
82 #include <linux/errno.h>
83 #include <linux/in.h>
84 #include <linux/mm.h>
85 #include <linux/inet.h>
86 #include <linux/inetdevice.h>
87 #include <linux/netdevice.h>
88 #include <linux/etherdevice.h>
89 #include <linux/fddidevice.h>
90 #include <linux/if_arp.h>
91 #include <linux/trdevice.h>
92 #include <linux/skbuff.h>
93 #include <linux/proc_fs.h>
94 #include <linux/seq_file.h>
95 #include <linux/stat.h>
96 #include <linux/init.h>
97 #include <linux/net.h>
98 #include <linux/rcupdate.h>
99 #include <linux/jhash.h>
100 #ifdef CONFIG_SYSCTL
101 #include <linux/sysctl.h>
102 #endif
103 
104 #include <net/net_namespace.h>
105 #include <net/ip.h>
106 #include <net/icmp.h>
107 #include <net/route.h>
108 #include <net/protocol.h>
109 #include <net/tcp.h>
110 #include <net/sock.h>
111 #include <net/arp.h>
112 #include <net/ax25.h>
113 #include <net/netrom.h>
114 #if defined(CONFIG_ATM_CLIP) || defined(CONFIG_ATM_CLIP_MODULE)
115 #include <net/atmclip.h>
116 struct neigh_table *clip_tbl_hook;
117 #endif
118 
119 #include <asm/system.h>
120 #include <asm/uaccess.h>
121 
122 #include <linux/netfilter_arp.h>
123 
124 /*
125  *	Interface to generic neighbour cache.
126  */
127 static u32 arp_hash(const void *pkey, const struct net_device *dev);
128 static int arp_constructor(struct neighbour *neigh);
129 static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb);
130 static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb);
131 static void parp_redo(struct sk_buff *skb);
132 
133 static struct neigh_ops arp_generic_ops = {
134 	.family =		AF_INET,
135 	.solicit =		arp_solicit,
136 	.error_report =		arp_error_report,
137 	.output =		neigh_resolve_output,
138 	.connected_output =	neigh_connected_output,
139 	.hh_output =		dev_queue_xmit,
140 	.queue_xmit =		dev_queue_xmit,
141 };
142 
143 static struct neigh_ops arp_hh_ops = {
144 	.family =		AF_INET,
145 	.solicit =		arp_solicit,
146 	.error_report =		arp_error_report,
147 	.output =		neigh_resolve_output,
148 	.connected_output =	neigh_resolve_output,
149 	.hh_output =		dev_queue_xmit,
150 	.queue_xmit =		dev_queue_xmit,
151 };
152 
153 static struct neigh_ops arp_direct_ops = {
154 	.family =		AF_INET,
155 	.output =		dev_queue_xmit,
156 	.connected_output =	dev_queue_xmit,
157 	.hh_output =		dev_queue_xmit,
158 	.queue_xmit =		dev_queue_xmit,
159 };
160 
161 struct neigh_ops arp_broken_ops = {
162 	.family =		AF_INET,
163 	.solicit =		arp_solicit,
164 	.error_report =		arp_error_report,
165 	.output =		neigh_compat_output,
166 	.connected_output =	neigh_compat_output,
167 	.hh_output =		dev_queue_xmit,
168 	.queue_xmit =		dev_queue_xmit,
169 };
170 
171 struct neigh_table arp_tbl = {
172 	.family =	AF_INET,
173 	.entry_size =	sizeof(struct neighbour) + 4,
174 	.key_len =	4,
175 	.hash =		arp_hash,
176 	.constructor =	arp_constructor,
177 	.proxy_redo =	parp_redo,
178 	.id =		"arp_cache",
179 	.parms = {
180 		.tbl =			&arp_tbl,
181 		.base_reachable_time =	30 * HZ,
182 		.retrans_time =	1 * HZ,
183 		.gc_staletime =	60 * HZ,
184 		.reachable_time =		30 * HZ,
185 		.delay_probe_time =	5 * HZ,
186 		.queue_len =		3,
187 		.ucast_probes =	3,
188 		.mcast_probes =	3,
189 		.anycast_delay =	1 * HZ,
190 		.proxy_delay =		(8 * HZ) / 10,
191 		.proxy_qlen =		64,
192 		.locktime =		1 * HZ,
193 	},
194 	.gc_interval =	30 * HZ,
195 	.gc_thresh1 =	128,
196 	.gc_thresh2 =	512,
197 	.gc_thresh3 =	1024,
198 };
199 
200 int arp_mc_map(__be32 addr, u8 *haddr, struct net_device *dev, int dir)
201 {
202 	switch (dev->type) {
203 	case ARPHRD_ETHER:
204 	case ARPHRD_FDDI:
205 	case ARPHRD_IEEE802:
206 		ip_eth_mc_map(addr, haddr);
207 		return 0;
208 	case ARPHRD_IEEE802_TR:
209 		ip_tr_mc_map(addr, haddr);
210 		return 0;
211 	case ARPHRD_INFINIBAND:
212 		ip_ib_mc_map(addr, dev->broadcast, haddr);
213 		return 0;
214 	default:
215 		if (dir) {
216 			memcpy(haddr, dev->broadcast, dev->addr_len);
217 			return 0;
218 		}
219 	}
220 	return -EINVAL;
221 }
222 
223 
224 static u32 arp_hash(const void *pkey, const struct net_device *dev)
225 {
226 	return jhash_2words(*(u32 *)pkey, dev->ifindex, arp_tbl.hash_rnd);
227 }
228 
229 static int arp_constructor(struct neighbour *neigh)
230 {
231 	__be32 addr = *(__be32*)neigh->primary_key;
232 	struct net_device *dev = neigh->dev;
233 	struct in_device *in_dev;
234 	struct neigh_parms *parms;
235 
236 	rcu_read_lock();
237 	in_dev = __in_dev_get_rcu(dev);
238 	if (in_dev == NULL) {
239 		rcu_read_unlock();
240 		return -EINVAL;
241 	}
242 
243 	neigh->type = inet_addr_type(dev_net(dev), addr);
244 
245 	parms = in_dev->arp_parms;
246 	__neigh_parms_put(neigh->parms);
247 	neigh->parms = neigh_parms_clone(parms);
248 	rcu_read_unlock();
249 
250 	if (!dev->header_ops) {
251 		neigh->nud_state = NUD_NOARP;
252 		neigh->ops = &arp_direct_ops;
253 		neigh->output = neigh->ops->queue_xmit;
254 	} else {
255 		/* Good devices (checked by reading texts, but only Ethernet is
256 		   tested)
257 
258 		   ARPHRD_ETHER: (ethernet, apfddi)
259 		   ARPHRD_FDDI: (fddi)
260 		   ARPHRD_IEEE802: (tr)
261 		   ARPHRD_METRICOM: (strip)
262 		   ARPHRD_ARCNET:
263 		   etc. etc. etc.
264 
265 		   ARPHRD_IPDDP will also work, if author repairs it.
266 		   I did not it, because this driver does not work even
267 		   in old paradigm.
268 		 */
269 
270 #if 1
271 		/* So... these "amateur" devices are hopeless.
272 		   The only thing, that I can say now:
273 		   It is very sad that we need to keep ugly obsolete
274 		   code to make them happy.
275 
276 		   They should be moved to more reasonable state, now
277 		   they use rebuild_header INSTEAD OF hard_start_xmit!!!
278 		   Besides that, they are sort of out of date
279 		   (a lot of redundant clones/copies, useless in 2.1),
280 		   I wonder why people believe that they work.
281 		 */
282 		switch (dev->type) {
283 		default:
284 			break;
285 		case ARPHRD_ROSE:
286 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
287 		case ARPHRD_AX25:
288 #if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
289 		case ARPHRD_NETROM:
290 #endif
291 			neigh->ops = &arp_broken_ops;
292 			neigh->output = neigh->ops->output;
293 			return 0;
294 #endif
295 		;}
296 #endif
297 		if (neigh->type == RTN_MULTICAST) {
298 			neigh->nud_state = NUD_NOARP;
299 			arp_mc_map(addr, neigh->ha, dev, 1);
300 		} else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
301 			neigh->nud_state = NUD_NOARP;
302 			memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
303 		} else if (neigh->type == RTN_BROADCAST || dev->flags&IFF_POINTOPOINT) {
304 			neigh->nud_state = NUD_NOARP;
305 			memcpy(neigh->ha, dev->broadcast, dev->addr_len);
306 		}
307 
308 		if (dev->header_ops->cache)
309 			neigh->ops = &arp_hh_ops;
310 		else
311 			neigh->ops = &arp_generic_ops;
312 
313 		if (neigh->nud_state&NUD_VALID)
314 			neigh->output = neigh->ops->connected_output;
315 		else
316 			neigh->output = neigh->ops->output;
317 	}
318 	return 0;
319 }
320 
321 static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb)
322 {
323 	dst_link_failure(skb);
324 	kfree_skb(skb);
325 }
326 
327 static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb)
328 {
329 	__be32 saddr = 0;
330 	u8  *dst_ha = NULL;
331 	struct net_device *dev = neigh->dev;
332 	__be32 target = *(__be32*)neigh->primary_key;
333 	int probes = atomic_read(&neigh->probes);
334 	struct in_device *in_dev = in_dev_get(dev);
335 
336 	if (!in_dev)
337 		return;
338 
339 	switch (IN_DEV_ARP_ANNOUNCE(in_dev)) {
340 	default:
341 	case 0:		/* By default announce any local IP */
342 		if (skb && inet_addr_type(dev_net(dev), ip_hdr(skb)->saddr) == RTN_LOCAL)
343 			saddr = ip_hdr(skb)->saddr;
344 		break;
345 	case 1:		/* Restrict announcements of saddr in same subnet */
346 		if (!skb)
347 			break;
348 		saddr = ip_hdr(skb)->saddr;
349 		if (inet_addr_type(dev_net(dev), saddr) == RTN_LOCAL) {
350 			/* saddr should be known to target */
351 			if (inet_addr_onlink(in_dev, target, saddr))
352 				break;
353 		}
354 		saddr = 0;
355 		break;
356 	case 2:		/* Avoid secondary IPs, get a primary/preferred one */
357 		break;
358 	}
359 
360 	if (in_dev)
361 		in_dev_put(in_dev);
362 	if (!saddr)
363 		saddr = inet_select_addr(dev, target, RT_SCOPE_LINK);
364 
365 	if ((probes -= neigh->parms->ucast_probes) < 0) {
366 		if (!(neigh->nud_state&NUD_VALID))
367 			printk(KERN_DEBUG "trying to ucast probe in NUD_INVALID\n");
368 		dst_ha = neigh->ha;
369 		read_lock_bh(&neigh->lock);
370 	} else if ((probes -= neigh->parms->app_probes) < 0) {
371 #ifdef CONFIG_ARPD
372 		neigh_app_ns(neigh);
373 #endif
374 		return;
375 	}
376 
377 	arp_send(ARPOP_REQUEST, ETH_P_ARP, target, dev, saddr,
378 		 dst_ha, dev->dev_addr, NULL);
379 	if (dst_ha)
380 		read_unlock_bh(&neigh->lock);
381 }
382 
383 static int arp_ignore(struct in_device *in_dev, __be32 sip, __be32 tip)
384 {
385 	int scope;
386 
387 	switch (IN_DEV_ARP_IGNORE(in_dev)) {
388 	case 0:	/* Reply, the tip is already validated */
389 		return 0;
390 	case 1:	/* Reply only if tip is configured on the incoming interface */
391 		sip = 0;
392 		scope = RT_SCOPE_HOST;
393 		break;
394 	case 2:	/*
395 		 * Reply only if tip is configured on the incoming interface
396 		 * and is in same subnet as sip
397 		 */
398 		scope = RT_SCOPE_HOST;
399 		break;
400 	case 3:	/* Do not reply for scope host addresses */
401 		sip = 0;
402 		scope = RT_SCOPE_LINK;
403 		break;
404 	case 4:	/* Reserved */
405 	case 5:
406 	case 6:
407 	case 7:
408 		return 0;
409 	case 8:	/* Do not reply */
410 		return 1;
411 	default:
412 		return 0;
413 	}
414 	return !inet_confirm_addr(in_dev, sip, tip, scope);
415 }
416 
417 static int arp_filter(__be32 sip, __be32 tip, struct net_device *dev)
418 {
419 	struct flowi fl = { .nl_u = { .ip4_u = { .daddr = sip,
420 						 .saddr = tip } } };
421 	struct rtable *rt;
422 	int flag = 0;
423 	/*unsigned long now; */
424 	struct net *net = dev_net(dev);
425 
426 	if (ip_route_output_key(net, &rt, &fl) < 0)
427 		return 1;
428 	if (rt->u.dst.dev != dev) {
429 		NET_INC_STATS_BH(net, LINUX_MIB_ARPFILTER);
430 		flag = 1;
431 	}
432 	ip_rt_put(rt);
433 	return flag;
434 }
435 
436 /* OBSOLETE FUNCTIONS */
437 
438 /*
439  *	Find an arp mapping in the cache. If not found, post a request.
440  *
441  *	It is very UGLY routine: it DOES NOT use skb->dst->neighbour,
442  *	even if it exists. It is supposed that skb->dev was mangled
443  *	by a virtual device (eql, shaper). Nobody but broken devices
444  *	is allowed to use this function, it is scheduled to be removed. --ANK
445  */
446 
447 static int arp_set_predefined(int addr_hint, unsigned char * haddr, __be32 paddr, struct net_device * dev)
448 {
449 	switch (addr_hint) {
450 	case RTN_LOCAL:
451 		printk(KERN_DEBUG "ARP: arp called for own IP address\n");
452 		memcpy(haddr, dev->dev_addr, dev->addr_len);
453 		return 1;
454 	case RTN_MULTICAST:
455 		arp_mc_map(paddr, haddr, dev, 1);
456 		return 1;
457 	case RTN_BROADCAST:
458 		memcpy(haddr, dev->broadcast, dev->addr_len);
459 		return 1;
460 	}
461 	return 0;
462 }
463 
464 
465 int arp_find(unsigned char *haddr, struct sk_buff *skb)
466 {
467 	struct net_device *dev = skb->dev;
468 	__be32 paddr;
469 	struct neighbour *n;
470 
471 	if (!skb->dst) {
472 		printk(KERN_DEBUG "arp_find is called with dst==NULL\n");
473 		kfree_skb(skb);
474 		return 1;
475 	}
476 
477 	paddr = skb->rtable->rt_gateway;
478 
479 	if (arp_set_predefined(inet_addr_type(dev_net(dev), paddr), haddr, paddr, dev))
480 		return 0;
481 
482 	n = __neigh_lookup(&arp_tbl, &paddr, dev, 1);
483 
484 	if (n) {
485 		n->used = jiffies;
486 		if (n->nud_state&NUD_VALID || neigh_event_send(n, skb) == 0) {
487 			read_lock_bh(&n->lock);
488 			memcpy(haddr, n->ha, dev->addr_len);
489 			read_unlock_bh(&n->lock);
490 			neigh_release(n);
491 			return 0;
492 		}
493 		neigh_release(n);
494 	} else
495 		kfree_skb(skb);
496 	return 1;
497 }
498 
499 /* END OF OBSOLETE FUNCTIONS */
500 
501 int arp_bind_neighbour(struct dst_entry *dst)
502 {
503 	struct net_device *dev = dst->dev;
504 	struct neighbour *n = dst->neighbour;
505 
506 	if (dev == NULL)
507 		return -EINVAL;
508 	if (n == NULL) {
509 		__be32 nexthop = ((struct rtable *)dst)->rt_gateway;
510 		if (dev->flags&(IFF_LOOPBACK|IFF_POINTOPOINT))
511 			nexthop = 0;
512 		n = __neigh_lookup_errno(
513 #if defined(CONFIG_ATM_CLIP) || defined(CONFIG_ATM_CLIP_MODULE)
514 		    dev->type == ARPHRD_ATM ? clip_tbl_hook :
515 #endif
516 		    &arp_tbl, &nexthop, dev);
517 		if (IS_ERR(n))
518 			return PTR_ERR(n);
519 		dst->neighbour = n;
520 	}
521 	return 0;
522 }
523 
524 /*
525  * Check if we can use proxy ARP for this path
526  */
527 
528 static inline int arp_fwd_proxy(struct in_device *in_dev, struct rtable *rt)
529 {
530 	struct in_device *out_dev;
531 	int imi, omi = -1;
532 
533 	if (!IN_DEV_PROXY_ARP(in_dev))
534 		return 0;
535 
536 	if ((imi = IN_DEV_MEDIUM_ID(in_dev)) == 0)
537 		return 1;
538 	if (imi == -1)
539 		return 0;
540 
541 	/* place to check for proxy_arp for routes */
542 
543 	if ((out_dev = in_dev_get(rt->u.dst.dev)) != NULL) {
544 		omi = IN_DEV_MEDIUM_ID(out_dev);
545 		in_dev_put(out_dev);
546 	}
547 	return (omi != imi && omi != -1);
548 }
549 
550 /*
551  *	Interface to link layer: send routine and receive handler.
552  */
553 
554 /*
555  *	Create an arp packet. If (dest_hw == NULL), we create a broadcast
556  *	message.
557  */
558 struct sk_buff *arp_create(int type, int ptype, __be32 dest_ip,
559 			   struct net_device *dev, __be32 src_ip,
560 			   const unsigned char *dest_hw,
561 			   const unsigned char *src_hw,
562 			   const unsigned char *target_hw)
563 {
564 	struct sk_buff *skb;
565 	struct arphdr *arp;
566 	unsigned char *arp_ptr;
567 
568 	/*
569 	 *	Allocate a buffer
570 	 */
571 
572 	skb = alloc_skb(arp_hdr_len(dev) + LL_ALLOCATED_SPACE(dev), GFP_ATOMIC);
573 	if (skb == NULL)
574 		return NULL;
575 
576 	skb_reserve(skb, LL_RESERVED_SPACE(dev));
577 	skb_reset_network_header(skb);
578 	arp = (struct arphdr *) skb_put(skb, arp_hdr_len(dev));
579 	skb->dev = dev;
580 	skb->protocol = htons(ETH_P_ARP);
581 	if (src_hw == NULL)
582 		src_hw = dev->dev_addr;
583 	if (dest_hw == NULL)
584 		dest_hw = dev->broadcast;
585 
586 	/*
587 	 *	Fill the device header for the ARP frame
588 	 */
589 	if (dev_hard_header(skb, dev, ptype, dest_hw, src_hw, skb->len) < 0)
590 		goto out;
591 
592 	/*
593 	 * Fill out the arp protocol part.
594 	 *
595 	 * The arp hardware type should match the device type, except for FDDI,
596 	 * which (according to RFC 1390) should always equal 1 (Ethernet).
597 	 */
598 	/*
599 	 *	Exceptions everywhere. AX.25 uses the AX.25 PID value not the
600 	 *	DIX code for the protocol. Make these device structure fields.
601 	 */
602 	switch (dev->type) {
603 	default:
604 		arp->ar_hrd = htons(dev->type);
605 		arp->ar_pro = htons(ETH_P_IP);
606 		break;
607 
608 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
609 	case ARPHRD_AX25:
610 		arp->ar_hrd = htons(ARPHRD_AX25);
611 		arp->ar_pro = htons(AX25_P_IP);
612 		break;
613 
614 #if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
615 	case ARPHRD_NETROM:
616 		arp->ar_hrd = htons(ARPHRD_NETROM);
617 		arp->ar_pro = htons(AX25_P_IP);
618 		break;
619 #endif
620 #endif
621 
622 #ifdef CONFIG_FDDI
623 	case ARPHRD_FDDI:
624 		arp->ar_hrd = htons(ARPHRD_ETHER);
625 		arp->ar_pro = htons(ETH_P_IP);
626 		break;
627 #endif
628 #ifdef CONFIG_TR
629 	case ARPHRD_IEEE802_TR:
630 		arp->ar_hrd = htons(ARPHRD_IEEE802);
631 		arp->ar_pro = htons(ETH_P_IP);
632 		break;
633 #endif
634 	}
635 
636 	arp->ar_hln = dev->addr_len;
637 	arp->ar_pln = 4;
638 	arp->ar_op = htons(type);
639 
640 	arp_ptr=(unsigned char *)(arp+1);
641 
642 	memcpy(arp_ptr, src_hw, dev->addr_len);
643 	arp_ptr += dev->addr_len;
644 	memcpy(arp_ptr, &src_ip, 4);
645 	arp_ptr += 4;
646 	if (target_hw != NULL)
647 		memcpy(arp_ptr, target_hw, dev->addr_len);
648 	else
649 		memset(arp_ptr, 0, dev->addr_len);
650 	arp_ptr += dev->addr_len;
651 	memcpy(arp_ptr, &dest_ip, 4);
652 
653 	return skb;
654 
655 out:
656 	kfree_skb(skb);
657 	return NULL;
658 }
659 
660 /*
661  *	Send an arp packet.
662  */
663 void arp_xmit(struct sk_buff *skb)
664 {
665 	/* Send it off, maybe filter it using firewalling first.  */
666 	NF_HOOK(NFPROTO_ARP, NF_ARP_OUT, skb, NULL, skb->dev, dev_queue_xmit);
667 }
668 
669 /*
670  *	Create and send an arp packet.
671  */
672 void arp_send(int type, int ptype, __be32 dest_ip,
673 	      struct net_device *dev, __be32 src_ip,
674 	      const unsigned char *dest_hw, const unsigned char *src_hw,
675 	      const unsigned char *target_hw)
676 {
677 	struct sk_buff *skb;
678 
679 	/*
680 	 *	No arp on this interface.
681 	 */
682 
683 	if (dev->flags&IFF_NOARP)
684 		return;
685 
686 	skb = arp_create(type, ptype, dest_ip, dev, src_ip,
687 			 dest_hw, src_hw, target_hw);
688 	if (skb == NULL) {
689 		return;
690 	}
691 
692 	arp_xmit(skb);
693 }
694 
695 /*
696  *	Process an arp request.
697  */
698 
699 static int arp_process(struct sk_buff *skb)
700 {
701 	struct net_device *dev = skb->dev;
702 	struct in_device *in_dev = in_dev_get(dev);
703 	struct arphdr *arp;
704 	unsigned char *arp_ptr;
705 	struct rtable *rt;
706 	unsigned char *sha;
707 	__be32 sip, tip;
708 	u16 dev_type = dev->type;
709 	int addr_type;
710 	struct neighbour *n;
711 	struct net *net = dev_net(dev);
712 
713 	/* arp_rcv below verifies the ARP header and verifies the device
714 	 * is ARP'able.
715 	 */
716 
717 	if (in_dev == NULL)
718 		goto out;
719 
720 	arp = arp_hdr(skb);
721 
722 	switch (dev_type) {
723 	default:
724 		if (arp->ar_pro != htons(ETH_P_IP) ||
725 		    htons(dev_type) != arp->ar_hrd)
726 			goto out;
727 		break;
728 	case ARPHRD_ETHER:
729 	case ARPHRD_IEEE802_TR:
730 	case ARPHRD_FDDI:
731 	case ARPHRD_IEEE802:
732 		/*
733 		 * ETHERNET, Token Ring and Fibre Channel (which are IEEE 802
734 		 * devices, according to RFC 2625) devices will accept ARP
735 		 * hardware types of either 1 (Ethernet) or 6 (IEEE 802.2).
736 		 * This is the case also of FDDI, where the RFC 1390 says that
737 		 * FDDI devices should accept ARP hardware of (1) Ethernet,
738 		 * however, to be more robust, we'll accept both 1 (Ethernet)
739 		 * or 6 (IEEE 802.2)
740 		 */
741 		if ((arp->ar_hrd != htons(ARPHRD_ETHER) &&
742 		     arp->ar_hrd != htons(ARPHRD_IEEE802)) ||
743 		    arp->ar_pro != htons(ETH_P_IP))
744 			goto out;
745 		break;
746 	case ARPHRD_AX25:
747 		if (arp->ar_pro != htons(AX25_P_IP) ||
748 		    arp->ar_hrd != htons(ARPHRD_AX25))
749 			goto out;
750 		break;
751 	case ARPHRD_NETROM:
752 		if (arp->ar_pro != htons(AX25_P_IP) ||
753 		    arp->ar_hrd != htons(ARPHRD_NETROM))
754 			goto out;
755 		break;
756 	}
757 
758 	/* Understand only these message types */
759 
760 	if (arp->ar_op != htons(ARPOP_REPLY) &&
761 	    arp->ar_op != htons(ARPOP_REQUEST))
762 		goto out;
763 
764 /*
765  *	Extract fields
766  */
767 	arp_ptr= (unsigned char *)(arp+1);
768 	sha	= arp_ptr;
769 	arp_ptr += dev->addr_len;
770 	memcpy(&sip, arp_ptr, 4);
771 	arp_ptr += 4;
772 	arp_ptr += dev->addr_len;
773 	memcpy(&tip, arp_ptr, 4);
774 /*
775  *	Check for bad requests for 127.x.x.x and requests for multicast
776  *	addresses.  If this is one such, delete it.
777  */
778 	if (ipv4_is_loopback(tip) || ipv4_is_multicast(tip))
779 		goto out;
780 
781 /*
782  *     Special case: We must set Frame Relay source Q.922 address
783  */
784 	if (dev_type == ARPHRD_DLCI)
785 		sha = dev->broadcast;
786 
787 /*
788  *  Process entry.  The idea here is we want to send a reply if it is a
789  *  request for us or if it is a request for someone else that we hold
790  *  a proxy for.  We want to add an entry to our cache if it is a reply
791  *  to us or if it is a request for our address.
792  *  (The assumption for this last is that if someone is requesting our
793  *  address, they are probably intending to talk to us, so it saves time
794  *  if we cache their address.  Their address is also probably not in
795  *  our cache, since ours is not in their cache.)
796  *
797  *  Putting this another way, we only care about replies if they are to
798  *  us, in which case we add them to the cache.  For requests, we care
799  *  about those for us and those for our proxies.  We reply to both,
800  *  and in the case of requests for us we add the requester to the arp
801  *  cache.
802  */
803 
804 	/*
805 	 *  Special case: IPv4 duplicate address detection packet (RFC2131)
806 	 *  and Gratuitous ARP/ARP Announce. (RFC3927, Section 2.4)
807 	 */
808 	if (sip == 0 || tip == sip) {
809 		if (arp->ar_op == htons(ARPOP_REQUEST) &&
810 		    inet_addr_type(net, tip) == RTN_LOCAL &&
811 		    !arp_ignore(in_dev, sip, tip))
812 			arp_send(ARPOP_REPLY, ETH_P_ARP, sip, dev, tip, sha,
813 				 dev->dev_addr, sha);
814 		goto out;
815 	}
816 
817 	if (arp->ar_op == htons(ARPOP_REQUEST) &&
818 	    ip_route_input(skb, tip, sip, 0, dev) == 0) {
819 
820 		rt = skb->rtable;
821 		addr_type = rt->rt_type;
822 
823 		if (addr_type == RTN_LOCAL) {
824 			int dont_send = 0;
825 
826 			if (!dont_send)
827 				dont_send |= arp_ignore(in_dev,sip,tip);
828 			if (!dont_send && IN_DEV_ARPFILTER(in_dev))
829 				dont_send |= arp_filter(sip,tip,dev);
830 			if (!dont_send) {
831 				n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
832 				if (n) {
833 					arp_send(ARPOP_REPLY,ETH_P_ARP,sip,dev,tip,sha,dev->dev_addr,sha);
834 					neigh_release(n);
835 				}
836 			}
837 			goto out;
838 		} else if (IN_DEV_FORWARD(in_dev)) {
839 			    if (addr_type == RTN_UNICAST  && rt->u.dst.dev != dev &&
840 			     (arp_fwd_proxy(in_dev, rt) || pneigh_lookup(&arp_tbl, net, &tip, dev, 0))) {
841 				n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
842 				if (n)
843 					neigh_release(n);
844 
845 				if (NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED ||
846 				    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 
863 	if (IPV4_DEVCONF_ALL(dev_net(dev), ARP_ACCEPT)) {
864 		/* 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(net, sip) == RTN_UNICAST)
871 			n = __neigh_lookup(&arp_tbl, &sip, dev, 1);
872 	}
873 
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 
895 out:
896 	if (in_dev)
897 		in_dev_put(in_dev);
898 	consume_skb(skb);
899 	return 0;
900 }
901 
902 static void parp_redo(struct sk_buff *skb)
903 {
904 	arp_process(skb);
905 }
906 
907 
908 /*
909  *	Receive an arp request from the device layer.
910  */
911 
912 static int arp_rcv(struct sk_buff *skb, struct net_device *dev,
913 		   struct packet_type *pt, struct net_device *orig_dev)
914 {
915 	struct arphdr *arp;
916 
917 	/* ARP header, plus 2 device addresses, plus 2 IP addresses.  */
918 	if (!pskb_may_pull(skb, arp_hdr_len(dev)))
919 		goto freeskb;
920 
921 	arp = arp_hdr(skb);
922 	if (arp->ar_hln != dev->addr_len ||
923 	    dev->flags & IFF_NOARP ||
924 	    skb->pkt_type == PACKET_OTHERHOST ||
925 	    skb->pkt_type == PACKET_LOOPBACK ||
926 	    arp->ar_pln != 4)
927 		goto freeskb;
928 
929 	if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
930 		goto out_of_mem;
931 
932 	memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
933 
934 	return NF_HOOK(NFPROTO_ARP, NF_ARP_IN, skb, dev, NULL, arp_process);
935 
936 freeskb:
937 	kfree_skb(skb);
938 out_of_mem:
939 	return 0;
940 }
941 
942 /*
943  *	User level interface (ioctl)
944  */
945 
946 /*
947  *	Set (create) an ARP cache entry.
948  */
949 
950 static int arp_req_set_proxy(struct net *net, struct net_device *dev, int on)
951 {
952 	if (dev == NULL) {
953 		IPV4_DEVCONF_ALL(net, PROXY_ARP) = on;
954 		return 0;
955 	}
956 	if (__in_dev_get_rtnl(dev)) {
957 		IN_DEV_CONF_SET(__in_dev_get_rtnl(dev), PROXY_ARP, on);
958 		return 0;
959 	}
960 	return -ENXIO;
961 }
962 
963 static int arp_req_set_public(struct net *net, struct arpreq *r,
964 		struct net_device *dev)
965 {
966 	__be32 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
967 	__be32 mask = ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr;
968 
969 	if (mask && mask != htonl(0xFFFFFFFF))
970 		return -EINVAL;
971 	if (!dev && (r->arp_flags & ATF_COM)) {
972 		dev = dev_getbyhwaddr(net, r->arp_ha.sa_family,
973 				r->arp_ha.sa_data);
974 		if (!dev)
975 			return -ENODEV;
976 	}
977 	if (mask) {
978 		if (pneigh_lookup(&arp_tbl, net, &ip, dev, 1) == NULL)
979 			return -ENOBUFS;
980 		return 0;
981 	}
982 
983 	return arp_req_set_proxy(net, dev, 1);
984 }
985 
986 static int arp_req_set(struct net *net, struct arpreq *r,
987 		struct net_device * dev)
988 {
989 	__be32 ip;
990 	struct neighbour *neigh;
991 	int err;
992 
993 	if (r->arp_flags & ATF_PUBL)
994 		return arp_req_set_public(net, r, dev);
995 
996 	ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
997 	if (r->arp_flags & ATF_PERM)
998 		r->arp_flags |= ATF_COM;
999 	if (dev == NULL) {
1000 		struct flowi fl = { .nl_u = { .ip4_u = { .daddr = ip,
1001 							 .tos = RTO_ONLINK } } };
1002 		struct rtable * rt;
1003 		if ((err = ip_route_output_key(net, &rt, &fl)) != 0)
1004 			return err;
1005 		dev = rt->u.dst.dev;
1006 		ip_rt_put(rt);
1007 		if (!dev)
1008 			return -EINVAL;
1009 	}
1010 	switch (dev->type) {
1011 #ifdef CONFIG_FDDI
1012 	case ARPHRD_FDDI:
1013 		/*
1014 		 * According to RFC 1390, FDDI devices should accept ARP
1015 		 * hardware types of 1 (Ethernet).  However, to be more
1016 		 * robust, we'll accept hardware types of either 1 (Ethernet)
1017 		 * or 6 (IEEE 802.2).
1018 		 */
1019 		if (r->arp_ha.sa_family != ARPHRD_FDDI &&
1020 		    r->arp_ha.sa_family != ARPHRD_ETHER &&
1021 		    r->arp_ha.sa_family != ARPHRD_IEEE802)
1022 			return -EINVAL;
1023 		break;
1024 #endif
1025 	default:
1026 		if (r->arp_ha.sa_family != dev->type)
1027 			return -EINVAL;
1028 		break;
1029 	}
1030 
1031 	neigh = __neigh_lookup_errno(&arp_tbl, &ip, dev);
1032 	err = PTR_ERR(neigh);
1033 	if (!IS_ERR(neigh)) {
1034 		unsigned state = NUD_STALE;
1035 		if (r->arp_flags & ATF_PERM)
1036 			state = NUD_PERMANENT;
1037 		err = neigh_update(neigh, (r->arp_flags&ATF_COM) ?
1038 				   r->arp_ha.sa_data : NULL, state,
1039 				   NEIGH_UPDATE_F_OVERRIDE|
1040 				   NEIGH_UPDATE_F_ADMIN);
1041 		neigh_release(neigh);
1042 	}
1043 	return err;
1044 }
1045 
1046 static unsigned arp_state_to_flags(struct neighbour *neigh)
1047 {
1048 	unsigned flags = 0;
1049 	if (neigh->nud_state&NUD_PERMANENT)
1050 		flags = ATF_PERM|ATF_COM;
1051 	else if (neigh->nud_state&NUD_VALID)
1052 		flags = ATF_COM;
1053 	return flags;
1054 }
1055 
1056 /*
1057  *	Get an ARP cache entry.
1058  */
1059 
1060 static int arp_req_get(struct arpreq *r, struct net_device *dev)
1061 {
1062 	__be32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
1063 	struct neighbour *neigh;
1064 	int err = -ENXIO;
1065 
1066 	neigh = neigh_lookup(&arp_tbl, &ip, dev);
1067 	if (neigh) {
1068 		read_lock_bh(&neigh->lock);
1069 		memcpy(r->arp_ha.sa_data, neigh->ha, dev->addr_len);
1070 		r->arp_flags = arp_state_to_flags(neigh);
1071 		read_unlock_bh(&neigh->lock);
1072 		r->arp_ha.sa_family = dev->type;
1073 		strlcpy(r->arp_dev, dev->name, sizeof(r->arp_dev));
1074 		neigh_release(neigh);
1075 		err = 0;
1076 	}
1077 	return err;
1078 }
1079 
1080 static int arp_req_delete_public(struct net *net, struct arpreq *r,
1081 		struct net_device *dev)
1082 {
1083 	__be32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
1084 	__be32 mask = ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr;
1085 
1086 	if (mask == htonl(0xFFFFFFFF))
1087 		return pneigh_delete(&arp_tbl, net, &ip, dev);
1088 
1089 	if (mask)
1090 		return -EINVAL;
1091 
1092 	return arp_req_set_proxy(net, dev, 0);
1093 }
1094 
1095 static int arp_req_delete(struct net *net, struct arpreq *r,
1096 		struct net_device * dev)
1097 {
1098 	int err;
1099 	__be32 ip;
1100 	struct neighbour *neigh;
1101 
1102 	if (r->arp_flags & ATF_PUBL)
1103 		return arp_req_delete_public(net, r, dev);
1104 
1105 	ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
1106 	if (dev == NULL) {
1107 		struct flowi fl = { .nl_u = { .ip4_u = { .daddr = ip,
1108 							 .tos = RTO_ONLINK } } };
1109 		struct rtable * rt;
1110 		if ((err = ip_route_output_key(net, &rt, &fl)) != 0)
1111 			return err;
1112 		dev = rt->u.dst.dev;
1113 		ip_rt_put(rt);
1114 		if (!dev)
1115 			return -EINVAL;
1116 	}
1117 	err = -ENXIO;
1118 	neigh = neigh_lookup(&arp_tbl, &ip, dev);
1119 	if (neigh) {
1120 		if (neigh->nud_state&~NUD_NOARP)
1121 			err = neigh_update(neigh, NULL, NUD_FAILED,
1122 					   NEIGH_UPDATE_F_OVERRIDE|
1123 					   NEIGH_UPDATE_F_ADMIN);
1124 		neigh_release(neigh);
1125 	}
1126 	return err;
1127 }
1128 
1129 /*
1130  *	Handle an ARP layer I/O control request.
1131  */
1132 
1133 int arp_ioctl(struct net *net, unsigned int cmd, void __user *arg)
1134 {
1135 	int err;
1136 	struct arpreq r;
1137 	struct net_device *dev = NULL;
1138 
1139 	switch (cmd) {
1140 		case SIOCDARP:
1141 		case SIOCSARP:
1142 			if (!capable(CAP_NET_ADMIN))
1143 				return -EPERM;
1144 		case SIOCGARP:
1145 			err = copy_from_user(&r, arg, sizeof(struct arpreq));
1146 			if (err)
1147 				return -EFAULT;
1148 			break;
1149 		default:
1150 			return -EINVAL;
1151 	}
1152 
1153 	if (r.arp_pa.sa_family != AF_INET)
1154 		return -EPFNOSUPPORT;
1155 
1156 	if (!(r.arp_flags & ATF_PUBL) &&
1157 	    (r.arp_flags & (ATF_NETMASK|ATF_DONTPUB)))
1158 		return -EINVAL;
1159 	if (!(r.arp_flags & ATF_NETMASK))
1160 		((struct sockaddr_in *)&r.arp_netmask)->sin_addr.s_addr =
1161 							   htonl(0xFFFFFFFFUL);
1162 	rtnl_lock();
1163 	if (r.arp_dev[0]) {
1164 		err = -ENODEV;
1165 		if ((dev = __dev_get_by_name(net, r.arp_dev)) == NULL)
1166 			goto out;
1167 
1168 		/* Mmmm... It is wrong... ARPHRD_NETROM==0 */
1169 		if (!r.arp_ha.sa_family)
1170 			r.arp_ha.sa_family = dev->type;
1171 		err = -EINVAL;
1172 		if ((r.arp_flags & ATF_COM) && r.arp_ha.sa_family != dev->type)
1173 			goto out;
1174 	} else if (cmd == SIOCGARP) {
1175 		err = -ENODEV;
1176 		goto out;
1177 	}
1178 
1179 	switch (cmd) {
1180 	case SIOCDARP:
1181 		err = arp_req_delete(net, &r, dev);
1182 		break;
1183 	case SIOCSARP:
1184 		err = arp_req_set(net, &r, dev);
1185 		break;
1186 	case SIOCGARP:
1187 		err = arp_req_get(&r, dev);
1188 		if (!err && copy_to_user(arg, &r, sizeof(r)))
1189 			err = -EFAULT;
1190 		break;
1191 	}
1192 out:
1193 	rtnl_unlock();
1194 	return err;
1195 }
1196 
1197 static int arp_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1198 {
1199 	struct net_device *dev = ptr;
1200 
1201 	switch (event) {
1202 	case NETDEV_CHANGEADDR:
1203 		neigh_changeaddr(&arp_tbl, dev);
1204 		rt_cache_flush(dev_net(dev), 0);
1205 		break;
1206 	default:
1207 		break;
1208 	}
1209 
1210 	return NOTIFY_DONE;
1211 }
1212 
1213 static struct notifier_block arp_netdev_notifier = {
1214 	.notifier_call = arp_netdev_event,
1215 };
1216 
1217 /* Note, that it is not on notifier chain.
1218    It is necessary, that this routine was called after route cache will be
1219    flushed.
1220  */
1221 void arp_ifdown(struct net_device *dev)
1222 {
1223 	neigh_ifdown(&arp_tbl, dev);
1224 }
1225 
1226 
1227 /*
1228  *	Called once on startup.
1229  */
1230 
1231 static struct packet_type arp_packet_type __read_mostly = {
1232 	.type =	cpu_to_be16(ETH_P_ARP),
1233 	.func =	arp_rcv,
1234 };
1235 
1236 static int arp_proc_init(void);
1237 
1238 void __init arp_init(void)
1239 {
1240 	neigh_table_init(&arp_tbl);
1241 
1242 	dev_add_pack(&arp_packet_type);
1243 	arp_proc_init();
1244 #ifdef CONFIG_SYSCTL
1245 	neigh_sysctl_register(NULL, &arp_tbl.parms, NET_IPV4,
1246 			      NET_IPV4_NEIGH, "ipv4", NULL, NULL);
1247 #endif
1248 	register_netdevice_notifier(&arp_netdev_notifier);
1249 }
1250 
1251 #ifdef CONFIG_PROC_FS
1252 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1253 
1254 /* ------------------------------------------------------------------------ */
1255 /*
1256  *	ax25 -> ASCII conversion
1257  */
1258 static char *ax2asc2(ax25_address *a, char *buf)
1259 {
1260 	char c, *s;
1261 	int n;
1262 
1263 	for (n = 0, s = buf; n < 6; n++) {
1264 		c = (a->ax25_call[n] >> 1) & 0x7F;
1265 
1266 		if (c != ' ') *s++ = c;
1267 	}
1268 
1269 	*s++ = '-';
1270 
1271 	if ((n = ((a->ax25_call[6] >> 1) & 0x0F)) > 9) {
1272 		*s++ = '1';
1273 		n -= 10;
1274 	}
1275 
1276 	*s++ = n + '0';
1277 	*s++ = '\0';
1278 
1279 	if (*buf == '\0' || *buf == '-')
1280 	   return "*";
1281 
1282 	return buf;
1283 
1284 }
1285 #endif /* CONFIG_AX25 */
1286 
1287 #define HBUFFERLEN 30
1288 
1289 static void arp_format_neigh_entry(struct seq_file *seq,
1290 				   struct neighbour *n)
1291 {
1292 	char hbuffer[HBUFFERLEN];
1293 	int k, j;
1294 	char tbuf[16];
1295 	struct net_device *dev = n->dev;
1296 	int hatype = dev->type;
1297 
1298 	read_lock(&n->lock);
1299 	/* Convert hardware address to XX:XX:XX:XX ... form. */
1300 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1301 	if (hatype == ARPHRD_AX25 || hatype == ARPHRD_NETROM)
1302 		ax2asc2((ax25_address *)n->ha, hbuffer);
1303 	else {
1304 #endif
1305 	for (k = 0, j = 0; k < HBUFFERLEN - 3 && j < dev->addr_len; j++) {
1306 		hbuffer[k++] = hex_asc_hi(n->ha[j]);
1307 		hbuffer[k++] = hex_asc_lo(n->ha[j]);
1308 		hbuffer[k++] = ':';
1309 	}
1310 	hbuffer[--k] = 0;
1311 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1312 	}
1313 #endif
1314 	sprintf(tbuf, "%pI4", n->primary_key);
1315 	seq_printf(seq, "%-16s 0x%-10x0x%-10x%s     *        %s\n",
1316 		   tbuf, hatype, arp_state_to_flags(n), hbuffer, dev->name);
1317 	read_unlock(&n->lock);
1318 }
1319 
1320 static void arp_format_pneigh_entry(struct seq_file *seq,
1321 				    struct pneigh_entry *n)
1322 {
1323 	struct net_device *dev = n->dev;
1324 	int hatype = dev ? dev->type : 0;
1325 	char tbuf[16];
1326 
1327 	sprintf(tbuf, "%pI4", n->key);
1328 	seq_printf(seq, "%-16s 0x%-10x0x%-10x%s     *        %s\n",
1329 		   tbuf, hatype, ATF_PUBL | ATF_PERM, "00:00:00:00:00:00",
1330 		   dev ? dev->name : "*");
1331 }
1332 
1333 static int arp_seq_show(struct seq_file *seq, void *v)
1334 {
1335 	if (v == SEQ_START_TOKEN) {
1336 		seq_puts(seq, "IP address       HW type     Flags       "
1337 			      "HW address            Mask     Device\n");
1338 	} else {
1339 		struct neigh_seq_state *state = seq->private;
1340 
1341 		if (state->flags & NEIGH_SEQ_IS_PNEIGH)
1342 			arp_format_pneigh_entry(seq, v);
1343 		else
1344 			arp_format_neigh_entry(seq, v);
1345 	}
1346 
1347 	return 0;
1348 }
1349 
1350 static void *arp_seq_start(struct seq_file *seq, loff_t *pos)
1351 {
1352 	/* Don't want to confuse "arp -a" w/ magic entries,
1353 	 * so we tell the generic iterator to skip NUD_NOARP.
1354 	 */
1355 	return neigh_seq_start(seq, pos, &arp_tbl, NEIGH_SEQ_SKIP_NOARP);
1356 }
1357 
1358 /* ------------------------------------------------------------------------ */
1359 
1360 static const struct seq_operations arp_seq_ops = {
1361 	.start  = arp_seq_start,
1362 	.next   = neigh_seq_next,
1363 	.stop   = neigh_seq_stop,
1364 	.show   = arp_seq_show,
1365 };
1366 
1367 static int arp_seq_open(struct inode *inode, struct file *file)
1368 {
1369 	return seq_open_net(inode, file, &arp_seq_ops,
1370 			    sizeof(struct neigh_seq_state));
1371 }
1372 
1373 static const struct file_operations arp_seq_fops = {
1374 	.owner		= THIS_MODULE,
1375 	.open           = arp_seq_open,
1376 	.read           = seq_read,
1377 	.llseek         = seq_lseek,
1378 	.release	= seq_release_net,
1379 };
1380 
1381 
1382 static int __net_init arp_net_init(struct net *net)
1383 {
1384 	if (!proc_net_fops_create(net, "arp", S_IRUGO, &arp_seq_fops))
1385 		return -ENOMEM;
1386 	return 0;
1387 }
1388 
1389 static void __net_exit arp_net_exit(struct net *net)
1390 {
1391 	proc_net_remove(net, "arp");
1392 }
1393 
1394 static struct pernet_operations arp_net_ops = {
1395 	.init = arp_net_init,
1396 	.exit = arp_net_exit,
1397 };
1398 
1399 static int __init arp_proc_init(void)
1400 {
1401 	return register_pernet_subsys(&arp_net_ops);
1402 }
1403 
1404 #else /* CONFIG_PROC_FS */
1405 
1406 static int __init arp_proc_init(void)
1407 {
1408 	return 0;
1409 }
1410 
1411 #endif /* CONFIG_PROC_FS */
1412 
1413 EXPORT_SYMBOL(arp_broken_ops);
1414 EXPORT_SYMBOL(arp_find);
1415 EXPORT_SYMBOL(arp_create);
1416 EXPORT_SYMBOL(arp_xmit);
1417 EXPORT_SYMBOL(arp_send);
1418 EXPORT_SYMBOL(arp_tbl);
1419 
1420 #if defined(CONFIG_ATM_CLIP) || defined(CONFIG_ATM_CLIP_MODULE)
1421 EXPORT_SYMBOL(clip_tbl_hook);
1422 #endif
1423