~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/ipv4/arp.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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[MAX_ADDR_LEN], *dst_hw = 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                 neigh_ha_snapshot(dst_ha, neigh, dev);
367                 dst_hw = dst_ha;
368         } else {
369                 probes -= neigh->parms->app_probes;
370                 if (probes < 0) {
371                         neigh_app_ns(neigh);
372                         return;
373                 }
374         }
375 
376         arp_send(ARPOP_REQUEST, ETH_P_ARP, target, dev, saddr,
377                  dst_hw, dev->dev_addr, NULL);
378 }
379 
380 static int arp_ignore(struct in_device *in_dev, __be32 sip, __be32 tip)
381 {
382         int scope;
383 
384         switch (IN_DEV_ARP_IGNORE(in_dev)) {
385         case 0: /* Reply, the tip is already validated */
386                 return 0;
387         case 1: /* Reply only if tip is configured on the incoming interface */
388                 sip = 0;
389                 scope = RT_SCOPE_HOST;
390                 break;
391         case 2: /*
392                  * Reply only if tip is configured on the incoming interface
393                  * and is in same subnet as sip
394                  */
395                 scope = RT_SCOPE_HOST;
396                 break;
397         case 3: /* Do not reply for scope host addresses */
398                 sip = 0;
399                 scope = RT_SCOPE_LINK;
400                 break;
401         case 4: /* Reserved */
402         case 5:
403         case 6:
404         case 7:
405                 return 0;
406         case 8: /* Do not reply */
407                 return 1;
408         default:
409                 return 0;
410         }
411         return !inet_confirm_addr(in_dev, sip, tip, scope);
412 }
413 
414 static int arp_filter(__be32 sip, __be32 tip, struct net_device *dev)
415 {
416         struct rtable *rt;
417         int flag = 0;
418         /*unsigned long now; */
419         struct net *net = dev_net(dev);
420 
421         rt = ip_route_output(net, sip, tip, 0, 0);
422         if (IS_ERR(rt))
423                 return 1;
424         if (rt->dst.dev != dev) {
425                 NET_INC_STATS_BH(net, LINUX_MIB_ARPFILTER);
426                 flag = 1;
427         }
428         ip_rt_put(rt);
429         return flag;
430 }
431 
432 /* OBSOLETE FUNCTIONS */
433 
434 /*
435  *      Find an arp mapping in the cache. If not found, post a request.
436  *
437  *      It is very UGLY routine: it DOES NOT use skb->dst->neighbour,
438  *      even if it exists. It is supposed that skb->dev was mangled
439  *      by a virtual device (eql, shaper). Nobody but broken devices
440  *      is allowed to use this function, it is scheduled to be removed. --ANK
441  */
442 
443 static int arp_set_predefined(int addr_hint, unsigned char *haddr,
444                               __be32 paddr, struct net_device *dev)
445 {
446         switch (addr_hint) {
447         case RTN_LOCAL:
448                 pr_debug("arp called for own IP address\n");
449                 memcpy(haddr, dev->dev_addr, dev->addr_len);
450                 return 1;
451         case RTN_MULTICAST:
452                 arp_mc_map(paddr, haddr, dev, 1);
453                 return 1;
454         case RTN_BROADCAST:
455                 memcpy(haddr, dev->broadcast, dev->addr_len);
456                 return 1;
457         }
458         return 0;
459 }
460 
461 
462 int arp_find(unsigned char *haddr, struct sk_buff *skb)
463 {
464         struct net_device *dev = skb->dev;
465         __be32 paddr;
466         struct neighbour *n;
467 
468         if (!skb_dst(skb)) {
469                 pr_debug("arp_find is called with dst==NULL\n");
470                 kfree_skb(skb);
471                 return 1;
472         }
473 
474         paddr = rt_nexthop(skb_rtable(skb), ip_hdr(skb)->daddr);
475         if (arp_set_predefined(inet_addr_type(dev_net(dev), paddr), haddr,
476                                paddr, dev))
477                 return 0;
478 
479         n = __neigh_lookup(&arp_tbl, &paddr, dev, 1);
480 
481         if (n) {
482                 n->used = jiffies;
483                 if (n->nud_state & NUD_VALID || neigh_event_send(n, skb) == 0) {
484                         neigh_ha_snapshot(haddr, n, dev);
485                         neigh_release(n);
486                         return 0;
487                 }
488                 neigh_release(n);
489         } else
490                 kfree_skb(skb);
491         return 1;
492 }
493 EXPORT_SYMBOL(arp_find);
494 
495 /* END OF OBSOLETE FUNCTIONS */
496 
497 /*
498  * Check if we can use proxy ARP for this path
499  */
500 static inline int arp_fwd_proxy(struct in_device *in_dev,
501                                 struct net_device *dev, struct rtable *rt)
502 {
503         struct in_device *out_dev;
504         int imi, omi = -1;
505 
506         if (rt->dst.dev == dev)
507                 return 0;
508 
509         if (!IN_DEV_PROXY_ARP(in_dev))
510                 return 0;
511         imi = IN_DEV_MEDIUM_ID(in_dev);
512         if (imi == 0)
513                 return 1;
514         if (imi == -1)
515                 return 0;
516 
517         /* place to check for proxy_arp for routes */
518 
519         out_dev = __in_dev_get_rcu(rt->dst.dev);
520         if (out_dev)
521                 omi = IN_DEV_MEDIUM_ID(out_dev);
522 
523         return omi != imi && omi != -1;
524 }
525 
526 /*
527  * Check for RFC3069 proxy arp private VLAN (allow to send back to same dev)
528  *
529  * RFC3069 supports proxy arp replies back to the same interface.  This
530  * is done to support (ethernet) switch features, like RFC 3069, where
531  * the individual ports are not allowed to communicate with each
532  * other, BUT they are allowed to talk to the upstream router.  As
533  * described in RFC 3069, it is possible to allow these hosts to
534  * communicate through the upstream router, by proxy_arp'ing.
535  *
536  * RFC 3069: "VLAN Aggregation for Efficient IP Address Allocation"
537  *
538  *  This technology is known by different names:
539  *    In RFC 3069 it is called VLAN Aggregation.
540  *    Cisco and Allied Telesyn call it Private VLAN.
541  *    Hewlett-Packard call it Source-Port filtering or port-isolation.
542  *    Ericsson call it MAC-Forced Forwarding (RFC Draft).
543  *
544  */
545 static inline int arp_fwd_pvlan(struct in_device *in_dev,
546                                 struct net_device *dev, struct rtable *rt,
547                                 __be32 sip, __be32 tip)
548 {
549         /* Private VLAN is only concerned about the same ethernet segment */
550         if (rt->dst.dev != dev)
551                 return 0;
552 
553         /* Don't reply on self probes (often done by windowz boxes)*/
554         if (sip == tip)
555                 return 0;
556 
557         if (IN_DEV_PROXY_ARP_PVLAN(in_dev))
558                 return 1;
559         else
560                 return 0;
561 }
562 
563 /*
564  *      Interface to link layer: send routine and receive handler.
565  */
566 
567 /*
568  *      Create an arp packet. If (dest_hw == NULL), we create a broadcast
569  *      message.
570  */
571 struct sk_buff *arp_create(int type, int ptype, __be32 dest_ip,
572                            struct net_device *dev, __be32 src_ip,
573                            const unsigned char *dest_hw,
574                            const unsigned char *src_hw,
575                            const unsigned char *target_hw)
576 {
577         struct sk_buff *skb;
578         struct arphdr *arp;
579         unsigned char *arp_ptr;
580         int hlen = LL_RESERVED_SPACE(dev);
581         int tlen = dev->needed_tailroom;
582 
583         /*
584          *      Allocate a buffer
585          */
586 
587         skb = alloc_skb(arp_hdr_len(dev) + hlen + tlen, GFP_ATOMIC);
588         if (skb == NULL)
589                 return NULL;
590 
591         skb_reserve(skb, hlen);
592         skb_reset_network_header(skb);
593         arp = (struct arphdr *) skb_put(skb, arp_hdr_len(dev));
594         skb->dev = dev;
595         skb->protocol = htons(ETH_P_ARP);
596         if (src_hw == NULL)
597                 src_hw = dev->dev_addr;
598         if (dest_hw == NULL)
599                 dest_hw = dev->broadcast;
600 
601         /*
602          *      Fill the device header for the ARP frame
603          */
604         if (dev_hard_header(skb, dev, ptype, dest_hw, src_hw, skb->len) < 0)
605                 goto out;
606 
607         /*
608          * Fill out the arp protocol part.
609          *
610          * The arp hardware type should match the device type, except for FDDI,
611          * which (according to RFC 1390) should always equal 1 (Ethernet).
612          */
613         /*
614          *      Exceptions everywhere. AX.25 uses the AX.25 PID value not the
615          *      DIX code for the protocol. Make these device structure fields.
616          */
617         switch (dev->type) {
618         default:
619                 arp->ar_hrd = htons(dev->type);
620                 arp->ar_pro = htons(ETH_P_IP);
621                 break;
622 
623 #if IS_ENABLED(CONFIG_AX25)
624         case ARPHRD_AX25:
625                 arp->ar_hrd = htons(ARPHRD_AX25);
626                 arp->ar_pro = htons(AX25_P_IP);
627                 break;
628 
629 #if IS_ENABLED(CONFIG_NETROM)
630         case ARPHRD_NETROM:
631                 arp->ar_hrd = htons(ARPHRD_NETROM);
632                 arp->ar_pro = htons(AX25_P_IP);
633                 break;
634 #endif
635 #endif
636 
637 #if IS_ENABLED(CONFIG_FDDI)
638         case ARPHRD_FDDI:
639                 arp->ar_hrd = htons(ARPHRD_ETHER);
640                 arp->ar_pro = htons(ETH_P_IP);
641                 break;
642 #endif
643         }
644 
645         arp->ar_hln = dev->addr_len;
646         arp->ar_pln = 4;
647         arp->ar_op = htons(type);
648 
649         arp_ptr = (unsigned char *)(arp + 1);
650 
651         memcpy(arp_ptr, src_hw, dev->addr_len);
652         arp_ptr += dev->addr_len;
653         memcpy(arp_ptr, &src_ip, 4);
654         arp_ptr += 4;
655 
656         switch (dev->type) {
657 #if IS_ENABLED(CONFIG_FIREWIRE_NET)
658         case ARPHRD_IEEE1394:
659                 break;
660 #endif
661         default:
662                 if (target_hw != NULL)
663                         memcpy(arp_ptr, target_hw, dev->addr_len);
664                 else
665                         memset(arp_ptr, 0, dev->addr_len);
666                 arp_ptr += dev->addr_len;
667         }
668         memcpy(arp_ptr, &dest_ip, 4);
669 
670         return skb;
671 
672 out:
673         kfree_skb(skb);
674         return NULL;
675 }
676 EXPORT_SYMBOL(arp_create);
677 
678 /*
679  *      Send an arp packet.
680  */
681 void arp_xmit(struct sk_buff *skb)
682 {
683         /* Send it off, maybe filter it using firewalling first.  */
684         NF_HOOK(NFPROTO_ARP, NF_ARP_OUT, skb, NULL, skb->dev, dev_queue_xmit);
685 }
686 EXPORT_SYMBOL(arp_xmit);
687 
688 /*
689  *      Create and send an arp packet.
690  */
691 void arp_send(int type, int ptype, __be32 dest_ip,
692               struct net_device *dev, __be32 src_ip,
693               const unsigned char *dest_hw, const unsigned char *src_hw,
694               const unsigned char *target_hw)
695 {
696         struct sk_buff *skb;
697 
698         /*
699          *      No arp on this interface.
700          */
701 
702         if (dev->flags&IFF_NOARP)
703                 return;
704 
705         skb = arp_create(type, ptype, dest_ip, dev, src_ip,
706                          dest_hw, src_hw, target_hw);
707         if (skb == NULL)
708                 return;
709 
710         arp_xmit(skb);
711 }
712 EXPORT_SYMBOL(arp_send);
713 
714 /*
715  *      Process an arp request.
716  */
717 
718 static int arp_process(struct sk_buff *skb)
719 {
720         struct net_device *dev = skb->dev;
721         struct in_device *in_dev = __in_dev_get_rcu(dev);
722         struct arphdr *arp;
723         unsigned char *arp_ptr;
724         struct rtable *rt;
725         unsigned char *sha;
726         __be32 sip, tip;
727         u16 dev_type = dev->type;
728         int addr_type;
729         struct neighbour *n;
730         struct net *net = dev_net(dev);
731 
732         /* arp_rcv below verifies the ARP header and verifies the device
733          * is ARP'able.
734          */
735 
736         if (in_dev == NULL)
737                 goto out;
738 
739         arp = arp_hdr(skb);
740 
741         switch (dev_type) {
742         default:
743                 if (arp->ar_pro != htons(ETH_P_IP) ||
744                     htons(dev_type) != arp->ar_hrd)
745                         goto out;
746                 break;
747         case ARPHRD_ETHER:
748         case ARPHRD_FDDI:
749         case ARPHRD_IEEE802:
750                 /*
751                  * ETHERNET, and Fibre Channel (which are IEEE 802
752                  * devices, according to RFC 2625) devices will accept ARP
753                  * hardware types of either 1 (Ethernet) or 6 (IEEE 802.2).
754                  * This is the case also of FDDI, where the RFC 1390 says that
755                  * FDDI devices should accept ARP hardware of (1) Ethernet,
756                  * however, to be more robust, we'll accept both 1 (Ethernet)
757                  * or 6 (IEEE 802.2)
758                  */
759                 if ((arp->ar_hrd != htons(ARPHRD_ETHER) &&
760                      arp->ar_hrd != htons(ARPHRD_IEEE802)) ||
761                     arp->ar_pro != htons(ETH_P_IP))
762                         goto out;
763                 break;
764         case ARPHRD_AX25:
765                 if (arp->ar_pro != htons(AX25_P_IP) ||
766                     arp->ar_hrd != htons(ARPHRD_AX25))
767                         goto out;
768                 break;
769         case ARPHRD_NETROM:
770                 if (arp->ar_pro != htons(AX25_P_IP) ||
771                     arp->ar_hrd != htons(ARPHRD_NETROM))
772                         goto out;
773                 break;
774         }
775 
776         /* Understand only these message types */
777 
778         if (arp->ar_op != htons(ARPOP_REPLY) &&
779             arp->ar_op != htons(ARPOP_REQUEST))
780                 goto out;
781 
782 /*
783  *      Extract fields
784  */
785         arp_ptr = (unsigned char *)(arp + 1);
786         sha     = arp_ptr;
787         arp_ptr += dev->addr_len;
788         memcpy(&sip, arp_ptr, 4);
789         arp_ptr += 4;
790         switch (dev_type) {
791 #if IS_ENABLED(CONFIG_FIREWIRE_NET)
792         case ARPHRD_IEEE1394:
793                 break;
794 #endif
795         default:
796                 arp_ptr += dev->addr_len;
797         }
798         memcpy(&tip, arp_ptr, 4);
799 /*
800  *      Check for bad requests for 127.x.x.x and requests for multicast
801  *      addresses.  If this is one such, delete it.
802  */
803         if (ipv4_is_multicast(tip) ||
804             (!IN_DEV_ROUTE_LOCALNET(in_dev) && ipv4_is_loopback(tip)))
805                 goto out;
806 
807 /*
808  *     Special case: We must set Frame Relay source Q.922 address
809  */
810         if (dev_type == ARPHRD_DLCI)
811                 sha = dev->broadcast;
812 
813 /*
814  *  Process entry.  The idea here is we want to send a reply if it is a
815  *  request for us or if it is a request for someone else that we hold
816  *  a proxy for.  We want to add an entry to our cache if it is a reply
817  *  to us or if it is a request for our address.
818  *  (The assumption for this last is that if someone is requesting our
819  *  address, they are probably intending to talk to us, so it saves time
820  *  if we cache their address.  Their address is also probably not in
821  *  our cache, since ours is not in their cache.)
822  *
823  *  Putting this another way, we only care about replies if they are to
824  *  us, in which case we add them to the cache.  For requests, we care
825  *  about those for us and those for our proxies.  We reply to both,
826  *  and in the case of requests for us we add the requester to the arp
827  *  cache.
828  */
829 
830         /* Special case: IPv4 duplicate address detection packet (RFC2131) */
831         if (sip == 0) {
832                 if (arp->ar_op == htons(ARPOP_REQUEST) &&
833                     inet_addr_type(net, tip) == RTN_LOCAL &&
834                     !arp_ignore(in_dev, sip, tip))
835                         arp_send(ARPOP_REPLY, ETH_P_ARP, sip, dev, tip, sha,
836                                  dev->dev_addr, sha);
837                 goto out;
838         }
839 
840         if (arp->ar_op == htons(ARPOP_REQUEST) &&
841             ip_route_input_noref(skb, tip, sip, 0, dev) == 0) {
842 
843                 rt = skb_rtable(skb);
844                 addr_type = rt->rt_type;
845 
846                 if (addr_type == RTN_LOCAL) {
847                         int dont_send;
848 
849                         dont_send = arp_ignore(in_dev, sip, tip);
850                         if (!dont_send && IN_DEV_ARPFILTER(in_dev))
851                                 dont_send = arp_filter(sip, tip, dev);
852                         if (!dont_send) {
853                                 n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
854                                 if (n) {
855                                         arp_send(ARPOP_REPLY, ETH_P_ARP, sip,
856                                                  dev, tip, sha, dev->dev_addr,
857                                                  sha);
858                                         neigh_release(n);
859                                 }
860                         }
861                         goto out;
862                 } else if (IN_DEV_FORWARD(in_dev)) {
863                         if (addr_type == RTN_UNICAST  &&
864                             (arp_fwd_proxy(in_dev, dev, rt) ||
865                              arp_fwd_pvlan(in_dev, dev, rt, sip, tip) ||
866                              (rt->dst.dev != dev &&
867                               pneigh_lookup(&arp_tbl, net, &tip, dev, 0)))) {
868                                 n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
869                                 if (n)
870                                         neigh_release(n);
871 
872                                 if (NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED ||
873                                     skb->pkt_type == PACKET_HOST ||
874                                     in_dev->arp_parms->proxy_delay == 0) {
875                                         arp_send(ARPOP_REPLY, ETH_P_ARP, sip,
876                                                  dev, tip, sha, dev->dev_addr,
877                                                  sha);
878                                 } else {
879                                         pneigh_enqueue(&arp_tbl,
880                                                        in_dev->arp_parms, skb);
881                                         return 0;
882                                 }
883                                 goto out;
884                         }
885                 }
886         }
887 
888         /* Update our ARP tables */
889 
890         n = __neigh_lookup(&arp_tbl, &sip, dev, 0);
891 
892         if (IN_DEV_ARP_ACCEPT(in_dev)) {
893                 /* Unsolicited ARP is not accepted by default.
894                    It is possible, that this option should be enabled for some
895                    devices (strip is candidate)
896                  */
897                 if (n == NULL &&
898                     (arp->ar_op == htons(ARPOP_REPLY) ||
899                      (arp->ar_op == htons(ARPOP_REQUEST) && tip == sip)) &&
900                     inet_addr_type(net, sip) == RTN_UNICAST)
901                         n = __neigh_lookup(&arp_tbl, &sip, dev, 1);
902         }
903 
904         if (n) {
905                 int state = NUD_REACHABLE;
906                 int override;
907 
908                 /* If several different ARP replies follows back-to-back,
909                    use the FIRST one. It is possible, if several proxy
910                    agents are active. Taking the first reply prevents
911                    arp trashing and chooses the fastest router.
912                  */
913                 override = time_after(jiffies, n->updated + n->parms->locktime);
914 
915                 /* Broadcast replies and request packets
916                    do not assert neighbour reachability.
917                  */
918                 if (arp->ar_op != htons(ARPOP_REPLY) ||
919                     skb->pkt_type != PACKET_HOST)
920                         state = NUD_STALE;
921                 neigh_update(n, sha, state,
922                              override ? NEIGH_UPDATE_F_OVERRIDE : 0);
923                 neigh_release(n);
924         }
925 
926 out:
927         consume_skb(skb);
928         return 0;
929 }
930 
931 static void parp_redo(struct sk_buff *skb)
932 {
933         arp_process(skb);
934 }
935 
936 
937 /*
938  *      Receive an arp request from the device layer.
939  */
940 
941 static int arp_rcv(struct sk_buff *skb, struct net_device *dev,
942                    struct packet_type *pt, struct net_device *orig_dev)
943 {
944         const struct arphdr *arp;
945 
946         if (dev->flags & IFF_NOARP ||
947             skb->pkt_type == PACKET_OTHERHOST ||
948             skb->pkt_type == PACKET_LOOPBACK)
949                 goto freeskb;
950 
951         skb = skb_share_check(skb, GFP_ATOMIC);
952         if (!skb)
953                 goto out_of_mem;
954 
955         /* ARP header, plus 2 device addresses, plus 2 IP addresses.  */
956         if (!pskb_may_pull(skb, arp_hdr_len(dev)))
957                 goto freeskb;
958 
959         arp = arp_hdr(skb);
960         if (arp->ar_hln != dev->addr_len || arp->ar_pln != 4)
961                 goto freeskb;
962 
963         memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
964 
965         return NF_HOOK(NFPROTO_ARP, NF_ARP_IN, skb, dev, NULL, arp_process);
966 
967 freeskb:
968         kfree_skb(skb);
969 out_of_mem:
970         return 0;
971 }
972 
973 /*
974  *      User level interface (ioctl)
975  */
976 
977 /*
978  *      Set (create) an ARP cache entry.
979  */
980 
981 static int arp_req_set_proxy(struct net *net, struct net_device *dev, int on)
982 {
983         if (dev == NULL) {
984                 IPV4_DEVCONF_ALL(net, PROXY_ARP) = on;
985                 return 0;
986         }
987         if (__in_dev_get_rtnl(dev)) {
988                 IN_DEV_CONF_SET(__in_dev_get_rtnl(dev), PROXY_ARP, on);
989                 return 0;
990         }
991         return -ENXIO;
992 }
993 
994 static int arp_req_set_public(struct net *net, struct arpreq *r,
995                 struct net_device *dev)
996 {
997         __be32 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
998         __be32 mask = ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr;
999 
1000         if (mask && mask != htonl(0xFFFFFFFF))
1001                 return -EINVAL;
1002         if (!dev && (r->arp_flags & ATF_COM)) {
1003                 dev = dev_getbyhwaddr_rcu(net, r->arp_ha.sa_family,
1004                                       r->arp_ha.sa_data);
1005                 if (!dev)
1006                         return -ENODEV;
1007         }
1008         if (mask) {
1009                 if (pneigh_lookup(&arp_tbl, net, &ip, dev, 1) == NULL)
1010                         return -ENOBUFS;
1011                 return 0;
1012         }
1013 
1014         return arp_req_set_proxy(net, dev, 1);
1015 }
1016 
1017 static int arp_req_set(struct net *net, struct arpreq *r,
1018                        struct net_device *dev)
1019 {
1020         __be32 ip;
1021         struct neighbour *neigh;
1022         int err;
1023 
1024         if (r->arp_flags & ATF_PUBL)
1025                 return arp_req_set_public(net, r, dev);
1026 
1027         ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
1028         if (r->arp_flags & ATF_PERM)
1029                 r->arp_flags |= ATF_COM;
1030         if (dev == NULL) {
1031                 struct rtable *rt = ip_route_output(net, ip, 0, RTO_ONLINK, 0);
1032 
1033                 if (IS_ERR(rt))
1034                         return PTR_ERR(rt);
1035                 dev = rt->dst.dev;
1036                 ip_rt_put(rt);
1037                 if (!dev)
1038                         return -EINVAL;
1039         }
1040         switch (dev->type) {
1041 #if IS_ENABLED(CONFIG_FDDI)
1042         case ARPHRD_FDDI:
1043                 /*
1044                  * According to RFC 1390, FDDI devices should accept ARP
1045                  * hardware types of 1 (Ethernet).  However, to be more
1046                  * robust, we'll accept hardware types of either 1 (Ethernet)
1047                  * or 6 (IEEE 802.2).
1048                  */
1049                 if (r->arp_ha.sa_family != ARPHRD_FDDI &&
1050                     r->arp_ha.sa_family != ARPHRD_ETHER &&
1051                     r->arp_ha.sa_family != ARPHRD_IEEE802)
1052                         return -EINVAL;
1053                 break;
1054 #endif
1055         default:
1056                 if (r->arp_ha.sa_family != dev->type)
1057                         return -EINVAL;
1058                 break;
1059         }
1060 
1061         neigh = __neigh_lookup_errno(&arp_tbl, &ip, dev);
1062         err = PTR_ERR(neigh);
1063         if (!IS_ERR(neigh)) {
1064                 unsigned int state = NUD_STALE;
1065                 if (r->arp_flags & ATF_PERM)
1066                         state = NUD_PERMANENT;
1067                 err = neigh_update(neigh, (r->arp_flags & ATF_COM) ?
1068                                    r->arp_ha.sa_data : NULL, state,
1069                                    NEIGH_UPDATE_F_OVERRIDE |
1070                                    NEIGH_UPDATE_F_ADMIN);
1071                 neigh_release(neigh);
1072         }
1073         return err;
1074 }
1075 
1076 static unsigned int arp_state_to_flags(struct neighbour *neigh)
1077 {
1078         if (neigh->nud_state&NUD_PERMANENT)
1079                 return ATF_PERM | ATF_COM;
1080         else if (neigh->nud_state&NUD_VALID)
1081                 return ATF_COM;
1082         else
1083                 return 0;
1084 }
1085 
1086 /*
1087  *      Get an ARP cache entry.
1088  */
1089 
1090 static int arp_req_get(struct arpreq *r, struct net_device *dev)
1091 {
1092         __be32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
1093         struct neighbour *neigh;
1094         int err = -ENXIO;
1095 
1096         neigh = neigh_lookup(&arp_tbl, &ip, dev);
1097         if (neigh) {
1098                 read_lock_bh(&neigh->lock);
1099                 memcpy(r->arp_ha.sa_data, neigh->ha, dev->addr_len);
1100                 r->arp_flags = arp_state_to_flags(neigh);
1101                 read_unlock_bh(&neigh->lock);
1102                 r->arp_ha.sa_family = dev->type;
1103                 strlcpy(r->arp_dev, dev->name, sizeof(r->arp_dev));
1104                 neigh_release(neigh);
1105                 err = 0;
1106         }
1107         return err;
1108 }
1109 
1110 int arp_invalidate(struct net_device *dev, __be32 ip)
1111 {
1112         struct neighbour *neigh = neigh_lookup(&arp_tbl, &ip, dev);
1113         int err = -ENXIO;
1114 
1115         if (neigh) {
1116                 if (neigh->nud_state & ~NUD_NOARP)
1117                         err = neigh_update(neigh, NULL, NUD_FAILED,
1118                                            NEIGH_UPDATE_F_OVERRIDE|
1119                                            NEIGH_UPDATE_F_ADMIN);
1120                 neigh_release(neigh);
1121         }
1122 
1123         return err;
1124 }
1125 EXPORT_SYMBOL(arp_invalidate);
1126 
1127 static int arp_req_delete_public(struct net *net, struct arpreq *r,
1128                 struct net_device *dev)
1129 {
1130         __be32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
1131         __be32 mask = ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr;
1132 
1133         if (mask == htonl(0xFFFFFFFF))
1134                 return pneigh_delete(&arp_tbl, net, &ip, dev);
1135 
1136         if (mask)
1137                 return -EINVAL;
1138 
1139         return arp_req_set_proxy(net, dev, 0);
1140 }
1141 
1142 static int arp_req_delete(struct net *net, struct arpreq *r,
1143                           struct net_device *dev)
1144 {
1145         __be32 ip;
1146 
1147         if (r->arp_flags & ATF_PUBL)
1148                 return arp_req_delete_public(net, r, dev);
1149 
1150         ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
1151         if (dev == NULL) {
1152                 struct rtable *rt = ip_route_output(net, ip, 0, RTO_ONLINK, 0);
1153                 if (IS_ERR(rt))
1154                         return PTR_ERR(rt);
1155                 dev = rt->dst.dev;
1156                 ip_rt_put(rt);
1157                 if (!dev)
1158                         return -EINVAL;
1159         }
1160         return arp_invalidate(dev, ip);
1161 }
1162 
1163 /*
1164  *      Handle an ARP layer I/O control request.
1165  */
1166 
1167 int arp_ioctl(struct net *net, unsigned int cmd, void __user *arg)
1168 {
1169         int err;
1170         struct arpreq r;
1171         struct net_device *dev = NULL;
1172 
1173         switch (cmd) {
1174         case SIOCDARP:
1175         case SIOCSARP:
1176                 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1177                         return -EPERM;
1178         case SIOCGARP:
1179                 err = copy_from_user(&r, arg, sizeof(struct arpreq));
1180                 if (err)
1181                         return -EFAULT;
1182                 break;
1183         default:
1184                 return -EINVAL;
1185         }
1186 
1187         if (r.arp_pa.sa_family != AF_INET)
1188                 return -EPFNOSUPPORT;
1189 
1190         if (!(r.arp_flags & ATF_PUBL) &&
1191             (r.arp_flags & (ATF_NETMASK | ATF_DONTPUB)))
1192                 return -EINVAL;
1193         if (!(r.arp_flags & ATF_NETMASK))
1194                 ((struct sockaddr_in *)&r.arp_netmask)->sin_addr.s_addr =
1195                                                            htonl(0xFFFFFFFFUL);
1196         rtnl_lock();
1197         if (r.arp_dev[0]) {
1198                 err = -ENODEV;
1199                 dev = __dev_get_by_name(net, r.arp_dev);
1200                 if (dev == NULL)
1201                         goto out;
1202 
1203                 /* Mmmm... It is wrong... ARPHRD_NETROM==0 */
1204                 if (!r.arp_ha.sa_family)
1205                         r.arp_ha.sa_family = dev->type;
1206                 err = -EINVAL;
1207                 if ((r.arp_flags & ATF_COM) && r.arp_ha.sa_family != dev->type)
1208                         goto out;
1209         } else if (cmd == SIOCGARP) {
1210                 err = -ENODEV;
1211                 goto out;
1212         }
1213 
1214         switch (cmd) {
1215         case SIOCDARP:
1216                 err = arp_req_delete(net, &r, dev);
1217                 break;
1218         case SIOCSARP:
1219                 err = arp_req_set(net, &r, dev);
1220                 break;
1221         case SIOCGARP:
1222                 err = arp_req_get(&r, dev);
1223                 break;
1224         }
1225 out:
1226         rtnl_unlock();
1227         if (cmd == SIOCGARP && !err && copy_to_user(arg, &r, sizeof(r)))
1228                 err = -EFAULT;
1229         return err;
1230 }
1231 
1232 static int arp_netdev_event(struct notifier_block *this, unsigned long event,
1233                             void *ptr)
1234 {
1235         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1236         struct netdev_notifier_change_info *change_info;
1237 
1238         switch (event) {
1239         case NETDEV_CHANGEADDR:
1240                 neigh_changeaddr(&arp_tbl, dev);
1241                 rt_cache_flush(dev_net(dev));
1242                 break;
1243         case NETDEV_CHANGE:
1244                 change_info = ptr;
1245                 if (change_info->flags_changed & IFF_NOARP)
1246                         neigh_changeaddr(&arp_tbl, dev);
1247                 break;
1248         default:
1249                 break;
1250         }
1251 
1252         return NOTIFY_DONE;
1253 }
1254 
1255 static struct notifier_block arp_netdev_notifier = {
1256         .notifier_call = arp_netdev_event,
1257 };
1258 
1259 /* Note, that it is not on notifier chain.
1260    It is necessary, that this routine was called after route cache will be
1261    flushed.
1262  */
1263 void arp_ifdown(struct net_device *dev)
1264 {
1265         neigh_ifdown(&arp_tbl, dev);
1266 }
1267 
1268 
1269 /*
1270  *      Called once on startup.
1271  */
1272 
1273 static struct packet_type arp_packet_type __read_mostly = {
1274         .type = cpu_to_be16(ETH_P_ARP),
1275         .func = arp_rcv,
1276 };
1277 
1278 static int arp_proc_init(void);
1279 
1280 void __init arp_init(void)
1281 {
1282         neigh_table_init(&arp_tbl);
1283 
1284         dev_add_pack(&arp_packet_type);
1285         arp_proc_init();
1286 #ifdef CONFIG_SYSCTL
1287         neigh_sysctl_register(NULL, &arp_tbl.parms, "ipv4", NULL);
1288 #endif
1289         register_netdevice_notifier(&arp_netdev_notifier);
1290 }
1291 
1292 #ifdef CONFIG_PROC_FS
1293 #if IS_ENABLED(CONFIG_AX25)
1294 
1295 /* ------------------------------------------------------------------------ */
1296 /*
1297  *      ax25 -> ASCII conversion
1298  */
1299 static char *ax2asc2(ax25_address *a, char *buf)
1300 {
1301         char c, *s;
1302         int n;
1303 
1304         for (n = 0, s = buf; n < 6; n++) {
1305                 c = (a->ax25_call[n] >> 1) & 0x7F;
1306 
1307                 if (c != ' ')
1308                         *s++ = c;
1309         }
1310 
1311         *s++ = '-';
1312         n = (a->ax25_call[6] >> 1) & 0x0F;
1313         if (n > 9) {
1314                 *s++ = '1';
1315                 n -= 10;
1316         }
1317 
1318         *s++ = n + '';
1319         *s++ = '\0';
1320 
1321         if (*buf == '\0' || *buf == '-')
1322                 return "*";
1323 
1324         return buf;
1325 }
1326 #endif /* CONFIG_AX25 */
1327 
1328 #define HBUFFERLEN 30
1329 
1330 static void arp_format_neigh_entry(struct seq_file *seq,
1331                                    struct neighbour *n)
1332 {
1333         char hbuffer[HBUFFERLEN];
1334         int k, j;
1335         char tbuf[16];
1336         struct net_device *dev = n->dev;
1337         int hatype = dev->type;
1338 
1339         read_lock(&n->lock);
1340         /* Convert hardware address to XX:XX:XX:XX ... form. */
1341 #if IS_ENABLED(CONFIG_AX25)
1342         if (hatype == ARPHRD_AX25 || hatype == ARPHRD_NETROM)
1343                 ax2asc2((ax25_address *)n->ha, hbuffer);
1344         else {
1345 #endif
1346         for (k = 0, j = 0; k < HBUFFERLEN - 3 && j < dev->addr_len; j++) {
1347                 hbuffer[k++] = hex_asc_hi(n->ha[j]);
1348                 hbuffer[k++] = hex_asc_lo(n->ha[j]);
1349                 hbuffer[k++] = ':';
1350         }
1351         if (k != 0)
1352                 --k;
1353         hbuffer[k] = 0;
1354 #if IS_ENABLED(CONFIG_AX25)
1355         }
1356 #endif
1357         sprintf(tbuf, "%pI4", n->primary_key);
1358         seq_printf(seq, "%-16s 0x%-10x0x%-10x%s     *        %s\n",
1359                    tbuf, hatype, arp_state_to_flags(n), hbuffer, dev->name);
1360         read_unlock(&n->lock);
1361 }
1362 
1363 static void arp_format_pneigh_entry(struct seq_file *seq,
1364                                     struct pneigh_entry *n)
1365 {
1366         struct net_device *dev = n->dev;
1367         int hatype = dev ? dev->type : 0;
1368         char tbuf[16];
1369 
1370         sprintf(tbuf, "%pI4", n->key);
1371         seq_printf(seq, "%-16s 0x%-10x0x%-10x%s     *        %s\n",
1372                    tbuf, hatype, ATF_PUBL | ATF_PERM, "00:00:00:00:00:00",
1373                    dev ? dev->name : "*");
1374 }
1375 
1376 static int arp_seq_show(struct seq_file *seq, void *v)
1377 {
1378         if (v == SEQ_START_TOKEN) {
1379                 seq_puts(seq, "IP address       HW type     Flags       "
1380                               "HW address            Mask     Device\n");
1381         } else {
1382                 struct neigh_seq_state *state = seq->private;
1383 
1384                 if (state->flags & NEIGH_SEQ_IS_PNEIGH)
1385                         arp_format_pneigh_entry(seq, v);
1386                 else
1387                         arp_format_neigh_entry(seq, v);
1388         }
1389 
1390         return 0;
1391 }
1392 
1393 static void *arp_seq_start(struct seq_file *seq, loff_t *pos)
1394 {
1395         /* Don't want to confuse "arp -a" w/ magic entries,
1396          * so we tell the generic iterator to skip NUD_NOARP.
1397          */
1398         return neigh_seq_start(seq, pos, &arp_tbl, NEIGH_SEQ_SKIP_NOARP);
1399 }
1400 
1401 /* ------------------------------------------------------------------------ */
1402 
1403 static const struct seq_operations arp_seq_ops = {
1404         .start  = arp_seq_start,
1405         .next   = neigh_seq_next,
1406         .stop   = neigh_seq_stop,
1407         .show   = arp_seq_show,
1408 };
1409 
1410 static int arp_seq_open(struct inode *inode, struct file *file)
1411 {
1412         return seq_open_net(inode, file, &arp_seq_ops,
1413                             sizeof(struct neigh_seq_state));
1414 }
1415 
1416 static const struct file_operations arp_seq_fops = {
1417         .owner          = THIS_MODULE,
1418         .open           = arp_seq_open,
1419         .read           = seq_read,
1420         .llseek         = seq_lseek,
1421         .release        = seq_release_net,
1422 };
1423 
1424 
1425 static int __net_init arp_net_init(struct net *net)
1426 {
1427         if (!proc_create("arp", S_IRUGO, net->proc_net, &arp_seq_fops))
1428                 return -ENOMEM;
1429         return 0;
1430 }
1431 
1432 static void __net_exit arp_net_exit(struct net *net)
1433 {
1434         remove_proc_entry("arp", net->proc_net);
1435 }
1436 
1437 static struct pernet_operations arp_net_ops = {
1438         .init = arp_net_init,
1439         .exit = arp_net_exit,
1440 };
1441 
1442 static int __init arp_proc_init(void)
1443 {
1444         return register_pernet_subsys(&arp_net_ops);
1445 }
1446 
1447 #else /* CONFIG_PROC_FS */
1448 
1449 static int __init arp_proc_init(void)
1450 {
1451         return 0;
1452 }
1453 
1454 #endif /* CONFIG_PROC_FS */
1455 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp