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