net/ipv4/arp.c

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