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