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