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