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  *              Harald Welte    :       convert to make use of jenkins hash
  75  */
  76
  77 #include <linux/module.h>
  78 #include <linux/types.h>
  79 #include <linux/string.h>
  80 #include <linux/kernel.h>
  81 #include <linux/sched.h>
  82 #include <linux/config.h>
  83 #include <linux/socket.h>
  84 #include <linux/sockios.h>
  85 #include <linux/errno.h>
  86 #include <linux/in.h>
  87 #include <linux/mm.h>
  88 #include <linux/inet.h>
  89 #include <linux/inetdevice.h>
  90 #include <linux/netdevice.h>
  91 #include <linux/etherdevice.h>
  92 #include <linux/fddidevice.h>
  93 #include <linux/if_arp.h>
  94 #include <linux/trdevice.h>
  95 #include <linux/skbuff.h>
  96 #include <linux/proc_fs.h>
  97 #include <linux/seq_file.h>
  98 #include <linux/stat.h>
  99 #include <linux/init.h>
 100 #include <linux/net.h>
 101 #include <linux/rcupdate.h>
 102 #include <linux/jhash.h>
 103 #ifdef CONFIG_SYSCTL
 104 #include <linux/sysctl.h>
 105 #endif
 106
 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 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
 115 #include <net/ax25.h>
 116 #if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
 117 #include <net/netrom.h>
 118 #endif
 119 #endif
 120 #if defined(CONFIG_ATM_CLIP) || defined(CONFIG_ATM_CLIP_MODULE)
 121 #include <net/atmclip.h>
 122 struct neigh_table *clip_tbl_hook;
 123 #endif
 124
 125 #include <asm/system.h>
 126 #include <asm/uaccess.h>
 127
 128 #include <linux/netfilter_arp.h>
 129
 130 /*
 131  *      Interface to generic neighbour cache.
 132  */
 133 static u32 arp_hash(const void *pkey, const struct net_device *dev);
 134 static int arp_constructor(struct neighbour *neigh);
 135 static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb);
 136 static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb);
 137 static void parp_redo(struct sk_buff *skb);
 138
 139 static struct neigh_ops arp_generic_ops = {
 140         .family =               AF_INET,
 141         .solicit =              arp_solicit,
 142         .error_report =         arp_error_report,
 143         .output =               neigh_resolve_output,
 144         .connected_output =     neigh_connected_output,
 145         .hh_output =            dev_queue_xmit,
 146         .queue_xmit =           dev_queue_xmit,
 147 };
 148
 149 static struct neigh_ops arp_hh_ops = {
 150         .family =               AF_INET,
 151         .solicit =              arp_solicit,
 152         .error_report =         arp_error_report,
 153         .output =               neigh_resolve_output,
 154         .connected_output =     neigh_resolve_output,
 155         .hh_output =            dev_queue_xmit,
 156         .queue_xmit =           dev_queue_xmit,
 157 };
 158
 159 static struct neigh_ops arp_direct_ops = {
 160         .family =               AF_INET,
 161         .output =               dev_queue_xmit,
 162         .connected_output =     dev_queue_xmit,
 163         .hh_output =            dev_queue_xmit,
 164         .queue_xmit =           dev_queue_xmit,
 165 };
 166
 167 struct neigh_ops arp_broken_ops = {
 168         .family =               AF_INET,
 169         .solicit =              arp_solicit,
 170         .error_report =         arp_error_report,
 171         .output =               neigh_compat_output,
 172         .connected_output =     neigh_compat_output,
 173         .hh_output =            dev_queue_xmit,
 174         .queue_xmit =           dev_queue_xmit,
 175 };
 176
 177 struct neigh_table arp_tbl = {
 178         .family =       AF_INET,
 179         .entry_size =   sizeof(struct neighbour) + 4,
 180         .key_len =      4,
 181         .hash =         arp_hash,
 182         .constructor =  arp_constructor,
 183         .proxy_redo =   parp_redo,
 184         .id =           "arp_cache",
 185         .parms = {
 186                 .tbl =                  &arp_tbl,
 187                 .base_reachable_time =  30 * HZ,
 188                 .retrans_time = 1 * HZ,
 189                 .gc_staletime = 60 * HZ,
 190                 .reachable_time =               30 * HZ,
 191                 .delay_probe_time =     5 * HZ,
 192                 .queue_len =            3,
 193                 .ucast_probes = 3,
 194                 .mcast_probes = 3,
 195                 .anycast_delay =        1 * HZ,
 196                 .proxy_delay =          (8 * HZ) / 10,
 197                 .proxy_qlen =           64,
 198                 .locktime =             1 * HZ,
 199         },
 200         .gc_interval =  30 * HZ,
 201         .gc_thresh1 =   128,
 202         .gc_thresh2 =   512,
 203         .gc_thresh3 =   1024,
 204 };
 205
 206 int arp_mc_map(u32 addr, u8 *haddr, struct net_device *dev, int dir)
 207 {
 208         switch (dev->type) {
 209         case ARPHRD_ETHER:
 210         case ARPHRD_FDDI:
 211         case ARPHRD_IEEE802:
 212                 ip_eth_mc_map(addr, haddr);
 213                 return 0;
 214         case ARPHRD_IEEE802_TR:
 215                 ip_tr_mc_map(addr, haddr);
 216                 return 0;
 217         case ARPHRD_INFINIBAND:
 218                 ip_ib_mc_map(addr, haddr);
 219                 return 0;
 220         default:
 221                 if (dir) {
 222                         memcpy(haddr, dev->broadcast, dev->addr_len);
 223                         return 0;
 224                 }
 225         }
 226         return -EINVAL;
 227 }
 228
 229
 230 static u32 arp_hash(const void *pkey, const struct net_device *dev)
 231 {
 232         return jhash_2words(*(u32 *)pkey, dev->ifindex, arp_tbl.hash_rnd);
 233 }
 234
 235 static int arp_constructor(struct neighbour *neigh)
 236 {
 237         u32 addr = *(u32*)neigh->primary_key;
 238         struct net_device *dev = neigh->dev;
 239         struct in_device *in_dev;
 240         struct neigh_parms *parms;
 241
 242         neigh->type = inet_addr_type(addr);
 243
 244         rcu_read_lock();
 245         in_dev = __in_dev_get_rcu(dev);
 246         if (in_dev == NULL) {
 247                 rcu_read_unlock();
 248                 return -EINVAL;
 249         }
 250
 251         parms = in_dev->arp_parms;
 252         __neigh_parms_put(neigh->parms);
 253         neigh->parms = neigh_parms_clone(parms);
 254         rcu_read_unlock();
 255
 256         if (dev->hard_header == NULL) {
 257                 neigh->nud_state = NUD_NOARP;
 258                 neigh->ops = &arp_direct_ops;
 259                 neigh->output = neigh->ops->queue_xmit;
 260         } else {
 261                 /* Good devices (checked by reading texts, but only Ethernet is
 262                    tested)
 263
 264                    ARPHRD_ETHER: (ethernet, apfddi)
 265                    ARPHRD_FDDI: (fddi)
 266                    ARPHRD_IEEE802: (tr)
 267                    ARPHRD_METRICOM: (strip)
 268                    ARPHRD_ARCNET:
 269                    etc. etc. etc.
 270
 271                    ARPHRD_IPDDP will also work, if author repairs it.
 272                    I did not it, because this driver does not work even
 273                    in old paradigm.
 274                  */
 275
 276 #if 1
 277                 /* So... these "amateur" devices are hopeless.
 278                    The only thing, that I can say now:
 279                    It is very sad that we need to keep ugly obsolete
 280                    code to make them happy.
 281
 282                    They should be moved to more reasonable state, now
 283                    they use rebuild_header INSTEAD OF hard_start_xmit!!!
 284                    Besides that, they are sort of out of date
 285                    (a lot of redundant clones/copies, useless in 2.1),
 286                    I wonder why people believe that they work.
 287                  */
 288                 switch (dev->type) {
 289                 default:
 290                         break;
 291                 case ARPHRD_ROSE:
 292 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
 293                 case ARPHRD_AX25:
 294 #if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
 295                 case ARPHRD_NETROM:
 296 #endif
 297                         neigh->ops = &arp_broken_ops;
 298                         neigh->output = neigh->ops->output;
 299                         return 0;
 300 #endif
 301                 ;}
 302 #endif
 303                 if (neigh->type == RTN_MULTICAST) {
 304                         neigh->nud_state = NUD_NOARP;
 305                         arp_mc_map(addr, neigh->ha, dev, 1);
 306                 } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
 307                         neigh->nud_state = NUD_NOARP;
 308                         memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
 309                 } else if (neigh->type == RTN_BROADCAST || dev->flags&IFF_POINTOPOINT) {
 310                         neigh->nud_state = NUD_NOARP;
 311                         memcpy(neigh->ha, dev->broadcast, dev->addr_len);
 312                 }
 313                 if (dev->hard_header_cache)
 314                         neigh->ops = &arp_hh_ops;
 315                 else
 316                         neigh->ops = &arp_generic_ops;
 317                 if (neigh->nud_state&NUD_VALID)
 318                         neigh->output = neigh->ops->connected_output;
 319                 else
 320                         neigh->output = neigh->ops->output;
 321         }
 322         return 0;
 323 }
 324
 325 static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb)
 326 {
 327         dst_link_failure(skb);
 328         kfree_skb(skb);
 329 }
 330
 331 static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb)
 332 {
 333         u32 saddr = 0;
 334         u8  *dst_ha = NULL;
 335         struct net_device *dev = neigh->dev;
 336         u32 target = *(u32*)neigh->primary_key;
 337         int probes = atomic_read(&neigh->probes);
 338         struct in_device *in_dev = in_dev_get(dev);
 339
 340         if (!in_dev)
 341                 return;
 342
 343         switch (IN_DEV_ARP_ANNOUNCE(in_dev)) {
 344         default:
 345         case 0:         /* By default announce any local IP */
 346                 if (skb && inet_addr_type(skb->nh.iph->saddr) == RTN_LOCAL)
 347                         saddr = skb->nh.iph->saddr;
 348                 break;
 349         case 1:         /* Restrict announcements of saddr in same subnet */
 350                 if (!skb)
 351                         break;
 352                 saddr = skb->nh.iph->saddr;
 353                 if (inet_addr_type(saddr) == RTN_LOCAL) {
 354                         /* saddr should be known to target */
 355                         if (inet_addr_onlink(in_dev, target, saddr))
 356                                 break;
 357                 }
 358                 saddr = 0;
 359                 break;
 360         case 2:         /* Avoid secondary IPs, get a primary/preferred one */
 361                 break;
 362         }
 363
 364         if (in_dev)
 365                 in_dev_put(in_dev);
 366         if (!saddr)
 367                 saddr = inet_select_addr(dev, target, RT_SCOPE_LINK);
 368
 369         if ((probes -= neigh->parms->ucast_probes) < 0) {
 370                 if (!(neigh->nud_state&NUD_VALID))
 371                         printk(KERN_DEBUG "trying to ucast probe in NUD_INVALID\n");
 372                 dst_ha = neigh->ha;
 373                 read_lock_bh(&neigh->lock);
 374         } else if ((probes -= neigh->parms->app_probes) < 0) {
 375 #ifdef CONFIG_ARPD
 376                 neigh_app_ns(neigh);
 377 #endif
 378                 return;
 379         }
 380
 381         arp_send(ARPOP_REQUEST, ETH_P_ARP, target, dev, saddr,
 382                  dst_ha, dev->dev_addr, NULL);
 383         if (dst_ha)
 384                 read_unlock_bh(&neigh->lock);
 385 }
 386
 387 static int arp_ignore(struct in_device *in_dev, struct net_device *dev,
 388                       u32 sip, u32 tip)
 389 {
 390         int scope;
 391
 392         switch (IN_DEV_ARP_IGNORE(in_dev)) {
 393         case 0: /* Reply, the tip is already validated */
 394                 return 0;
 395         case 1: /* Reply only if tip is configured on the incoming interface */
 396                 sip = 0;
 397                 scope = RT_SCOPE_HOST;
 398                 break;
 399         case 2: /*
 400                  * Reply only if tip is configured on the incoming interface
 401                  * and is in same subnet as sip
 402                  */
 403                 scope = RT_SCOPE_HOST;
 404                 break;
 405         case 3: /* Do not reply for scope host addresses */
 406                 sip = 0;
 407                 scope = RT_SCOPE_LINK;
 408                 dev = NULL;
 409                 break;
 410         case 4: /* Reserved */
 411         case 5:
 412         case 6:
 413         case 7:
 414                 return 0;
 415         case 8: /* Do not reply */
 416                 return 1;
 417         default:
 418                 return 0;
 419         }
 420         return !inet_confirm_addr(dev, sip, tip, scope);
 421 }
 422
 423 static int arp_filter(__u32 sip, __u32 tip, struct net_device *dev)
 424 {
 425         struct flowi fl = { .nl_u = { .ip4_u = { .daddr = sip,
 426                                                  .saddr = tip } } };
 427         struct rtable *rt;
 428         int flag = 0;
 429         /*unsigned long now; */
 430
 431         if (ip_route_output_key(&rt, &fl) < 0)
 432                 return 1;
 433         if (rt->u.dst.dev != dev) {
 434                 NET_INC_STATS_BH(LINUX_MIB_ARPFILTER);
 435                 flag = 1;
 436         }
 437         ip_rt_put(rt);
 438         return flag;
 439 }
 440
 441 /* OBSOLETE FUNCTIONS */
 442
 443 /*
 444  *      Find an arp mapping in the cache. If not found, post a request.
 445  *
 446  *      It is very UGLY routine: it DOES NOT use skb->dst->neighbour,
 447  *      even if it exists. It is supposed that skb->dev was mangled
 448  *      by a virtual device (eql, shaper). Nobody but broken devices
 449  *      is allowed to use this function, it is scheduled to be removed. --ANK
 450  */
 451
 452 static int arp_set_predefined(int addr_hint, unsigned char * haddr, u32 paddr, struct net_device * dev)
 453 {
 454         switch (addr_hint) {
 455         case RTN_LOCAL:
 456                 printk(KERN_DEBUG "ARP: arp called for own IP address\n");
 457                 memcpy(haddr, dev->dev_addr, dev->addr_len);
 458                 return 1;
 459         case RTN_MULTICAST:
 460                 arp_mc_map(paddr, haddr, dev, 1);
 461                 return 1;
 462         case RTN_BROADCAST:
 463                 memcpy(haddr, dev->broadcast, dev->addr_len);
 464                 return 1;
 465         }
 466         return 0;
 467 }
 468
 469
 470 int arp_find(unsigned char *haddr, struct sk_buff *skb)
 471 {
 472         struct net_device *dev = skb->dev;
 473         u32 paddr;
 474         struct neighbour *n;
 475
 476         if (!skb->dst) {
 477                 printk(KERN_DEBUG "arp_find is called with dst==NULL\n");
 478                 kfree_skb(skb);
 479                 return 1;
 480         }
 481
 482         paddr = ((struct rtable*)skb->dst)->rt_gateway;
 483
 484         if (arp_set_predefined(inet_addr_type(paddr), haddr, paddr, dev))
 485                 return 0;
 486
 487         n = __neigh_lookup(&arp_tbl, &paddr, dev, 1);
 488
 489         if (n) {
 490                 n->used = jiffies;
 491                 if (n->nud_state&NUD_VALID || neigh_event_send(n, skb) == 0) {
 492                         read_lock_bh(&n->lock);
 493                         memcpy(haddr, n->ha, dev->addr_len);
 494                         read_unlock_bh(&n->lock);
 495                         neigh_release(n);
 496                         return 0;
 497                 }
 498                 neigh_release(n);
 499         } else
 500                 kfree_skb(skb);
 501         return 1;
 502 }
 503
 504 /* END OF OBSOLETE FUNCTIONS */
 505
 506 int arp_bind_neighbour(struct dst_entry *dst)
 507 {
 508         struct net_device *dev = dst->dev;
 509         struct neighbour *n = dst->neighbour;
 510
 511         if (dev == NULL)
 512                 return -EINVAL;
 513         if (n == NULL) {
 514                 u32 nexthop = ((struct rtable*)dst)->rt_gateway;
 515                 if (dev->flags&(IFF_LOOPBACK|IFF_POINTOPOINT))
 516                         nexthop = 0;
 517                 n = __neigh_lookup_errno(
 518 #if defined(CONFIG_ATM_CLIP) || defined(CONFIG_ATM_CLIP_MODULE)
 519                     dev->type == ARPHRD_ATM ? clip_tbl_hook :
 520 #endif
 521                     &arp_tbl, &nexthop, dev);
 522                 if (IS_ERR(n))
 523                         return PTR_ERR(n);
 524                 dst->neighbour = n;
 525         }
 526         return 0;
 527 }
 528
 529 /*
 530  * Check if we can use proxy ARP for this path
 531  */
 532
 533 static inline int arp_fwd_proxy(struct in_device *in_dev, struct rtable *rt)
 534 {
 535         struct in_device *out_dev;
 536         int imi, omi = -1;
 537
 538         if (!IN_DEV_PROXY_ARP(in_dev))
 539                 return 0;
 540
 541         if ((imi = IN_DEV_MEDIUM_ID(in_dev)) == 0)
 542                 return 1;
 543         if (imi == -1)
 544                 return 0;
 545
 546         /* place to check for proxy_arp for routes */
 547
 548         if ((out_dev = in_dev_get(rt->u.dst.dev)) != NULL) {
 549                 omi = IN_DEV_MEDIUM_ID(out_dev);
 550                 in_dev_put(out_dev);
 551         }
 552         return (omi != imi && omi != -1);
 553 }
 554
 555 /*
 556  *      Interface to link layer: send routine and receive handler.
 557  */
 558
 559 /*
 560  *      Create an arp packet. If (dest_hw == NULL), we create a broadcast
 561  *      message.
 562  */
 563 struct sk_buff *arp_create(int type, int ptype, u32 dest_ip,
 564                            struct net_device *dev, u32 src_ip,
 565                            unsigned char *dest_hw, unsigned char *src_hw,
 566                            unsigned char *target_hw)
 567 {
 568         struct sk_buff *skb;
 569         struct arphdr *arp;
 570         unsigned char *arp_ptr;
 571
 572         /*
 573          *      Allocate a buffer
 574          */
 575
 576         skb = alloc_skb(sizeof(struct arphdr)+ 2*(dev->addr_len+4)
 577                                 + LL_RESERVED_SPACE(dev), GFP_ATOMIC);
 578         if (skb == NULL)
 579                 return NULL;
 580
 581         skb_reserve(skb, LL_RESERVED_SPACE(dev));
 582         skb->nh.raw = skb->data;
 583         arp = (struct arphdr *) skb_put(skb,sizeof(struct arphdr) + 2*(dev->addr_len+4));
 584         skb->dev = dev;
 585         skb->protocol = htons(ETH_P_ARP);
 586         if (src_hw == NULL)
 587                 src_hw = dev->dev_addr;
 588         if (dest_hw == NULL)
 589                 dest_hw = dev->broadcast;
 590
 591         /*
 592          *      Fill the device header for the ARP frame
 593          */
 594         if (dev->hard_header &&
 595             dev->hard_header(skb,dev,ptype,dest_hw,src_hw,skb->len) < 0)
 596                 goto out;
 597
 598         /*
 599          * Fill out the arp protocol part.
 600          *
 601          * The arp hardware type should match the device type, except for FDDI,
 602          * which (according to RFC 1390) should always equal 1 (Ethernet).
 603          */
 604         /*
 605          *      Exceptions everywhere. AX.25 uses the AX.25 PID value not the
 606          *      DIX code for the protocol. Make these device structure fields.
 607          */
 608         switch (dev->type) {
 609         default:
 610                 arp->ar_hrd = htons(dev->type);
 611                 arp->ar_pro = htons(ETH_P_IP);
 612                 break;
 613
 614 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
 615         case ARPHRD_AX25:
 616                 arp->ar_hrd = htons(ARPHRD_AX25);
 617                 arp->ar_pro = htons(AX25_P_IP);
 618                 break;
 619
 620 #if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
 621         case ARPHRD_NETROM:
 622                 arp->ar_hrd = htons(ARPHRD_NETROM);
 623                 arp->ar_pro = htons(AX25_P_IP);
 624                 break;
 625 #endif
 626 #endif
 627
 628 #ifdef CONFIG_FDDI
 629         case ARPHRD_FDDI:
 630                 arp->ar_hrd = htons(ARPHRD_ETHER);
 631                 arp->ar_pro = htons(ETH_P_IP);
 632                 break;
 633 #endif
 634 #ifdef CONFIG_TR
 635         case ARPHRD_IEEE802_TR:
 636                 arp->ar_hrd = htons(ARPHRD_IEEE802);
 637                 arp->ar_pro = htons(ETH_P_IP);
 638                 break;
 639 #endif
 640         }
 641
 642         arp->ar_hln = dev->addr_len;
 643         arp->ar_pln = 4;
 644         arp->ar_op = htons(type);
 645
 646         arp_ptr=(unsigned char *)(arp+1);
 647
 648         memcpy(arp_ptr, src_hw, dev->addr_len);
 649         arp_ptr+=dev->addr_len;
 650         memcpy(arp_ptr, &src_ip,4);
 651         arp_ptr+=4;
 652         if (target_hw != NULL)
 653                 memcpy(arp_ptr, target_hw, dev->addr_len);
 654         else
 655                 memset(arp_ptr, 0, dev->addr_len);
 656         arp_ptr+=dev->addr_len;
 657         memcpy(arp_ptr, &dest_ip, 4);
 658
 659         return skb;
 660
 661 out:
 662         kfree_skb(skb);
 663         return NULL;
 664 }
 665
 666 /*
 667  *      Send an arp packet.
 668  */
 669 void arp_xmit(struct sk_buff *skb)
 670 {
 671         /* Send it off, maybe filter it using firewalling first.  */
 672         NF_HOOK(NF_ARP, NF_ARP_OUT, skb, NULL, skb->dev, dev_queue_xmit);
 673 }
 674
 675 /*
 676  *      Create and send an arp packet.
 677  */
 678 void arp_send(int type, int ptype, u32 dest_ip,
 679               struct net_device *dev, u32 src_ip,
 680               unsigned char *dest_hw, unsigned char *src_hw,
 681               unsigned char *target_hw)
 682 {
 683         struct sk_buff *skb;
 684
 685         /*
 686          *      No arp on this interface.
 687          */
 688
 689         if (dev->flags&IFF_NOARP)
 690                 return;
 691
 692         skb = arp_create(type, ptype, dest_ip, dev, src_ip,
 693                          dest_hw, src_hw, target_hw);
 694         if (skb == NULL) {
 695                 return;
 696         }
 697
 698         arp_xmit(skb);
 699 }
 700
 701 /*
 702  *      Process an arp request.
 703  */
 704
 705 static 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 (NEIGH_CB(skb)->flags & 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 ? NEIGH_UPDATE_F_OVERRIDE : 0);
 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 static void parp_redo(struct sk_buff *skb)
 921 {
 922         arp_process(skb);
 923 }
 924
 925
 926 /*
 927  *      Receive an arp request from the device layer.
 928  */
 929
 930 int arp_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
 931 {
 932         struct arphdr *arp;
 933
 934         /* ARP header, plus 2 device addresses, plus 2 IP addresses.  */
 935         if (!pskb_may_pull(skb, (sizeof(struct arphdr) +
 936                                  (2 * dev->addr_len) +
 937                                  (2 * sizeof(u32)))))
 938                 goto freeskb;
 939
 940         arp = skb->nh.arph;
 941         if (arp->ar_hln != dev->addr_len ||
 942             dev->flags & IFF_NOARP ||
 943             skb->pkt_type == PACKET_OTHERHOST ||
 944             skb->pkt_type == PACKET_LOOPBACK ||
 945             arp->ar_pln != 4)
 946                 goto freeskb;
 947
 948         if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
 949                 goto out_of_mem;
 950
 951         memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
 952
 953         return NF_HOOK(NF_ARP, NF_ARP_IN, skb, dev, NULL, arp_process);
 954
 955 freeskb:
 956         kfree_skb(skb);
 957 out_of_mem:
 958         return 0;
 959 }
 960
 961 /*
 962  *      User level interface (ioctl)
 963  */
 964
 965 /*
 966  *      Set (create) an ARP cache entry.
 967  */
 968
 969 static int arp_req_set(struct arpreq *r, struct net_device * dev)
 970 {
 971         u32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
 972         struct neighbour *neigh;
 973         int err;
 974
 975         if (r->arp_flags&ATF_PUBL) {
 976                 u32 mask = ((struct sockaddr_in *) &r->arp_netmask)->sin_addr.s_addr;
 977                 if (mask && mask != 0xFFFFFFFF)
 978                         return -EINVAL;
 979                 if (!dev && (r->arp_flags & ATF_COM)) {
 980                         dev = dev_getbyhwaddr(r->arp_ha.sa_family, r->arp_ha.sa_data);
 981                         if (!dev)
 982                                 return -ENODEV;
 983                 }
 984                 if (mask) {
 985                         if (pneigh_lookup(&arp_tbl, &ip, dev, 1) == NULL)
 986                                 return -ENOBUFS;
 987                         return 0;
 988                 }
 989                 if (dev == NULL) {
 990                         ipv4_devconf.proxy_arp = 1;
 991                         return 0;
 992                 }
 993                 if (__in_dev_get_rtnl(dev)) {
 994                         __in_dev_get_rtnl(dev)->cnf.proxy_arp = 1;
 995                         return 0;
 996                 }
 997                 return -ENXIO;
 998         }
 999
1000         if (r->arp_flags & ATF_PERM)
1001                 r->arp_flags |= ATF_COM;
1002         if (dev == NULL) {
1003                 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = ip,
1004                                                          .tos = RTO_ONLINK } } };
1005                 struct rtable * rt;
1006                 if ((err = ip_route_output_key(&rt, &fl)) != 0)
1007                         return err;
1008                 dev = rt->u.dst.dev;
1009                 ip_rt_put(rt);
1010                 if (!dev)
1011                         return -EINVAL;
1012         }
1013         switch (dev->type) {
1014 #ifdef CONFIG_FDDI
1015         case ARPHRD_FDDI:
1016                 /*
1017                  * According to RFC 1390, FDDI devices should accept ARP
1018                  * hardware types of 1 (Ethernet).  However, to be more
1019                  * robust, we'll accept hardware types of either 1 (Ethernet)
1020                  * or 6 (IEEE 802.2).
1021                  */
1022                 if (r->arp_ha.sa_family != ARPHRD_FDDI &&
1023                     r->arp_ha.sa_family != ARPHRD_ETHER &&
1024                     r->arp_ha.sa_family != ARPHRD_IEEE802)
1025                         return -EINVAL;
1026                 break;
1027 #endif
1028         default:
1029                 if (r->arp_ha.sa_family != dev->type)
1030                         return -EINVAL;
1031                 break;
1032         }
1033
1034         neigh = __neigh_lookup_errno(&arp_tbl, &ip, dev);
1035         err = PTR_ERR(neigh);
1036         if (!IS_ERR(neigh)) {
1037                 unsigned state = NUD_STALE;
1038                 if (r->arp_flags & ATF_PERM)
1039                         state = NUD_PERMANENT;
1040                 err = neigh_update(neigh, (r->arp_flags&ATF_COM) ?
1041                                    r->arp_ha.sa_data : NULL, state,
1042                                    NEIGH_UPDATE_F_OVERRIDE|
1043                                    NEIGH_UPDATE_F_ADMIN);
1044                 neigh_release(neigh);
1045         }
1046         return err;
1047 }
1048
1049 static unsigned arp_state_to_flags(struct neighbour *neigh)
1050 {
1051         unsigned flags = 0;
1052         if (neigh->nud_state&NUD_PERMANENT)
1053                 flags = ATF_PERM|ATF_COM;
1054         else if (neigh->nud_state&NUD_VALID)
1055                 flags = ATF_COM;
1056         return flags;
1057 }
1058
1059 /*
1060  *      Get an ARP cache entry.
1061  */
1062
1063 static int arp_req_get(struct arpreq *r, struct net_device *dev)
1064 {
1065         u32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
1066         struct neighbour *neigh;
1067         int err = -ENXIO;
1068
1069         neigh = neigh_lookup(&arp_tbl, &ip, dev);
1070         if (neigh) {
1071                 read_lock_bh(&neigh->lock);
1072                 memcpy(r->arp_ha.sa_data, neigh->ha, dev->addr_len);
1073                 r->arp_flags = arp_state_to_flags(neigh);
1074                 read_unlock_bh(&neigh->lock);
1075                 r->arp_ha.sa_family = dev->type;
1076                 strlcpy(r->arp_dev, dev->name, sizeof(r->arp_dev));
1077                 neigh_release(neigh);
1078                 err = 0;
1079         }
1080         return err;
1081 }
1082
1083 static int arp_req_delete(struct arpreq *r, struct net_device * dev)
1084 {
1085         int err;
1086         u32 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
1087         struct neighbour *neigh;
1088
1089         if (r->arp_flags & ATF_PUBL) {
1090                 u32 mask =
1091                        ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr;
1092                 if (mask == 0xFFFFFFFF)
1093                         return pneigh_delete(&arp_tbl, &ip, dev);
1094                 if (mask == 0) {
1095                         if (dev == NULL) {
1096                                 ipv4_devconf.proxy_arp = 0;
1097                                 return 0;
1098                         }
1099                         if (__in_dev_get_rtnl(dev)) {
1100                                 __in_dev_get_rtnl(dev)->cnf.proxy_arp = 0;
1101                                 return 0;
1102                         }
1103                         return -ENXIO;
1104                 }
1105                 return -EINVAL;
1106         }
1107
1108         if (dev == NULL) {
1109                 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = ip,
1110                                                          .tos = RTO_ONLINK } } };
1111                 struct rtable * rt;
1112                 if ((err = ip_route_output_key(&rt, &fl)) != 0)
1113                         return err;
1114                 dev = rt->u.dst.dev;
1115                 ip_rt_put(rt);
1116                 if (!dev)
1117                         return -EINVAL;
1118         }
1119         err = -ENXIO;
1120         neigh = neigh_lookup(&arp_tbl, &ip, dev);
1121         if (neigh) {
1122                 if (neigh->nud_state&~NUD_NOARP)
1123                         err = neigh_update(neigh, NULL, NUD_FAILED,
1124                                            NEIGH_UPDATE_F_OVERRIDE|
1125                                            NEIGH_UPDATE_F_ADMIN);
1126                 neigh_release(neigh);
1127         }
1128         return err;
1129 }
1130
1131 /*
1132  *      Handle an ARP layer I/O control request.
1133  */
1134
1135 int arp_ioctl(unsigned int cmd, void __user *arg)
1136 {
1137         int err;
1138         struct arpreq r;
1139         struct net_device *dev = NULL;
1140
1141         switch (cmd) {
1142                 case SIOCDARP:
1143                 case SIOCSARP:
1144                         if (!capable(CAP_NET_ADMIN))
1145                                 return -EPERM;
1146                 case SIOCGARP:
1147                         err = copy_from_user(&r, arg, sizeof(struct arpreq));
1148                         if (err)
1149                                 return -EFAULT;
1150                         break;
1151                 default:
1152                         return -EINVAL;
1153         }
1154
1155         if (r.arp_pa.sa_family != AF_INET)
1156                 return -EPFNOSUPPORT;
1157
1158         if (!(r.arp_flags & ATF_PUBL) &&
1159             (r.arp_flags & (ATF_NETMASK|ATF_DONTPUB)))
1160                 return -EINVAL;
1161         if (!(r.arp_flags & ATF_NETMASK))
1162                 ((struct sockaddr_in *)&r.arp_netmask)->sin_addr.s_addr =
1163                                                            htonl(0xFFFFFFFFUL);
1164         rtnl_lock();
1165         if (r.arp_dev[0]) {
1166                 err = -ENODEV;
1167                 if ((dev = __dev_get_by_name(r.arp_dev)) == NULL)
1168                         goto out;
1169
1170                 /* Mmmm... It is wrong... ARPHRD_NETROM==0 */
1171                 if (!r.arp_ha.sa_family)
1172                         r.arp_ha.sa_family = dev->type;
1173                 err = -EINVAL;
1174                 if ((r.arp_flags & ATF_COM) && r.arp_ha.sa_family != dev->type)
1175                         goto out;
1176         } else if (cmd == SIOCGARP) {
1177                 err = -ENODEV;
1178                 goto out;
1179         }
1180
1181         switch(cmd) {
1182         case SIOCDARP:
1183                 err = arp_req_delete(&r, dev);
1184                 break;
1185         case SIOCSARP:
1186                 err = arp_req_set(&r, dev);
1187                 break;
1188         case SIOCGARP:
1189                 err = arp_req_get(&r, dev);
1190                 if (!err && copy_to_user(arg, &r, sizeof(r)))
1191                         err = -EFAULT;
1192                 break;
1193         }
1194 out:
1195         rtnl_unlock();
1196         return err;
1197 }
1198
1199 static int arp_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1200 {
1201         struct net_device *dev = ptr;
1202
1203         switch (event) {
1204         case NETDEV_CHANGEADDR:
1205                 neigh_changeaddr(&arp_tbl, dev);
1206                 rt_cache_flush(0);
1207                 break;
1208         default:
1209                 break;
1210         }
1211
1212         return NOTIFY_DONE;
1213 }
1214
1215 static struct notifier_block arp_netdev_notifier = {
1216         .notifier_call = arp_netdev_event,
1217 };
1218
1219 /* Note, that it is not on notifier chain.
1220    It is necessary, that this routine was called after route cache will be
1221    flushed.
1222  */
1223 void arp_ifdown(struct net_device *dev)
1224 {
1225         neigh_ifdown(&arp_tbl, dev);
1226 }
1227
1228
1229 /*
1230  *      Called once on startup.
1231  */
1232
1233 static struct packet_type arp_packet_type = {
1234         .type = __constant_htons(ETH_P_ARP),
1235         .func = arp_rcv,
1236 };
1237
1238 static int arp_proc_init(void);
1239
1240 void __init arp_init(void)
1241 {
1242         neigh_table_init(&arp_tbl);
1243
1244         dev_add_pack(&arp_packet_type);
1245         arp_proc_init();
1246 #ifdef CONFIG_SYSCTL
1247         neigh_sysctl_register(NULL, &arp_tbl.parms, NET_IPV4,
1248                               NET_IPV4_NEIGH, "ipv4", NULL, NULL);
1249 #endif
1250         register_netdevice_notifier(&arp_netdev_notifier);
1251 }
1252
1253 #ifdef CONFIG_PROC_FS
1254 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1255
1256 /* ------------------------------------------------------------------------ */
1257 /*
1258  *      ax25 -> ASCII conversion
1259  */
1260 static char *ax2asc2(ax25_address *a, char *buf)
1261 {
1262         char c, *s;
1263         int n;
1264
1265         for (n = 0, s = buf; n < 6; n++) {
1266                 c = (a->ax25_call[n] >> 1) & 0x7F;
1267
1268                 if (c != ' ') *s++ = c;
1269         }
1270
1271         *s++ = '-';
1272
1273         if ((n = ((a->ax25_call[6] >> 1) & 0x0F)) > 9) {
1274                 *s++ = '1';
1275                 n -= 10;
1276         }
1277
1278         *s++ = n + '0';
1279         *s++ = '\0';
1280
1281         if (*buf == '\0' || *buf == '-')
1282            return "*";
1283
1284         return buf;
1285
1286 }
1287 #endif /* CONFIG_AX25 */
1288
1289 #define HBUFFERLEN 30
1290
1291 static void arp_format_neigh_entry(struct seq_file *seq,
1292                                    struct neighbour *n)
1293 {
1294         char hbuffer[HBUFFERLEN];
1295         const char hexbuf[] = "0123456789ABCDEF";
1296         int k, j;
1297         char tbuf[16];
1298         struct net_device *dev = n->dev;
1299         int hatype = dev->type;
1300
1301         read_lock(&n->lock);
1302         /* Convert hardware address to XX:XX:XX:XX ... form. */
1303 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1304         if (hatype == ARPHRD_AX25 || hatype == ARPHRD_NETROM)
1305                 ax2asc2((ax25_address *)n->ha, hbuffer);
1306         else {
1307 #endif
1308         for (k = 0, j = 0; k < HBUFFERLEN - 3 && j < dev->addr_len; j++) {
1309                 hbuffer[k++] = hexbuf[(n->ha[j] >> 4) & 15];
1310                 hbuffer[k++] = hexbuf[n->ha[j] & 15];
1311                 hbuffer[k++] = ':';
1312         }
1313         hbuffer[--k] = 0;
1314 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1315         }
1316 #endif
1317         sprintf(tbuf, "%u.%u.%u.%u", NIPQUAD(*(u32*)n->primary_key));
1318         seq_printf(seq, "%-16s 0x%-10x0x%-10x%s     *        %s\n",
1319                    tbuf, hatype, arp_state_to_flags(n), hbuffer, dev->name);
1320         read_unlock(&n->lock);
1321 }
1322
1323 static void arp_format_pneigh_entry(struct seq_file *seq,
1324                                     struct pneigh_entry *n)
1325 {
1326         struct net_device *dev = n->dev;
1327         int hatype = dev ? dev->type : 0;
1328         char tbuf[16];
1329
1330         sprintf(tbuf, "%u.%u.%u.%u", NIPQUAD(*(u32*)n->key));
1331         seq_printf(seq, "%-16s 0x%-10x0x%-10x%s     *        %s\n",
1332                    tbuf, hatype, ATF_PUBL | ATF_PERM, "00:00:00:00:00:00",
1333                    dev ? dev->name : "*");
1334 }
1335
1336 static int arp_seq_show(struct seq_file *seq, void *v)
1337 {
1338         if (v == SEQ_START_TOKEN) {
1339                 seq_puts(seq, "IP address       HW type     Flags       "
1340                               "HW address            Mask     Device\n");
1341         } else {
1342                 struct neigh_seq_state *state = seq->private;
1343
1344                 if (state->flags & NEIGH_SEQ_IS_PNEIGH)
1345                         arp_format_pneigh_entry(seq, v);
1346                 else
1347                         arp_format_neigh_entry(seq, v);
1348         }
1349
1350         return 0;
1351 }
1352
1353 static void *arp_seq_start(struct seq_file *seq, loff_t *pos)
1354 {
1355         /* Don't want to confuse "arp -a" w/ magic entries,
1356          * so we tell the generic iterator to skip NUD_NOARP.
1357          */
1358         return neigh_seq_start(seq, pos, &arp_tbl, NEIGH_SEQ_SKIP_NOARP);
1359 }
1360
1361 /* ------------------------------------------------------------------------ */
1362
1363 static struct seq_operations arp_seq_ops = {
1364         .start  = arp_seq_start,
1365         .next   = neigh_seq_next,
1366         .stop   = neigh_seq_stop,
1367         .show   = arp_seq_show,
1368 };
1369
1370 static int arp_seq_open(struct inode *inode, struct file *file)
1371 {
1372         struct seq_file *seq;
1373         int rc = -ENOMEM;
1374         struct neigh_seq_state *s = kmalloc(sizeof(*s), GFP_KERNEL);
1375
1376         if (!s)
1377                 goto out;
1378
1379         memset(s, 0, sizeof(*s));
1380         rc = seq_open(file, &arp_seq_ops);
1381         if (rc)
1382                 goto out_kfree;
1383
1384         seq          = file->private_data;
1385         seq->private = s;
1386 out:
1387         return rc;
1388 out_kfree:
1389         kfree(s);
1390         goto out;
1391 }
1392
1393 static struct file_operations arp_seq_fops = {
1394         .owner          = THIS_MODULE,
1395         .open           = arp_seq_open,
1396         .read           = seq_read,
1397         .llseek         = seq_lseek,
1398         .release        = seq_release_private,
1399 };
1400
1401 static int __init arp_proc_init(void)
1402 {
1403         if (!proc_net_fops_create("arp", S_IRUGO, &arp_seq_fops))
1404                 return -ENOMEM;
1405         return 0;
1406 }
1407
1408 #else /* CONFIG_PROC_FS */
1409
1410 static int __init arp_proc_init(void)
1411 {
1412         return 0;
1413 }
1414
1415 #endif /* CONFIG_PROC_FS */
1416
1417 EXPORT_SYMBOL(arp_broken_ops);
1418 EXPORT_SYMBOL(arp_find);
1419 EXPORT_SYMBOL(arp_rcv);
1420 EXPORT_SYMBOL(arp_create);
1421 EXPORT_SYMBOL(arp_xmit);
1422 EXPORT_SYMBOL(arp_send);
1423 EXPORT_SYMBOL(arp_tbl);
1424
1425 #if defined(CONFIG_ATM_CLIP) || defined(CONFIG_ATM_CLIP_MODULE)
1426 EXPORT_SYMBOL(clip_tbl_hook);
1427 #endif