net/ipv4/arp.c

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