net/ipv4/arp.c

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