LCOV - code coverage report
Current view: top level - net/ipv4 - arp.c (source / functions) Hit Total Coverage
Test: landlock.info Lines: 200 573 34.9 %
Date: 2021-04-22 12:43:58 Functions: 16 37 43.2 %

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

Generated by: LCOV version 1.14