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