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