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