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