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