net/appletalk/aarp.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *      AARP:           An implementation of the AppleTalk AARP protocol for
   4  *                      Ethernet 'ELAP'.
   5  *
   6  *              Alan Cox  <Alan.Cox@linux.org>
   7  *
   8  *      This doesn't fit cleanly with the IP arp. Potentially we can use
   9  *      the generic neighbour discovery code to clean this up.
  10  *
  11  *      FIXME:
  12  *              We ought to handle the retransmits with a single list and a
  13  *      separate fast timer for when it is needed.
  14  *              Use neighbour discovery code.
  15  *              Token Ring Support.
  16  *
  17  *      References:
  18  *              Inside AppleTalk (2nd Ed).
  19  *      Fixes:
  20  *              Jaume Grau      -       flush caches on AARP_PROBE
  21  *              Rob Newberry    -       Added proxy AARP and AARP proc fs,
  22  *                                      moved probing from DDP module.
  23  *              Arnaldo C. Melo -       don't mangle rx packets
  24  */
  25
  26 #include <linux/if_arp.h>
  27 #include <linux/slab.h>
  28 #include <net/sock.h>
  29 #include <net/datalink.h>
  30 #include <net/psnap.h>
  31 #include <linux/atalk.h>
  32 #include <linux/delay.h>
  33 #include <linux/init.h>
  34 #include <linux/proc_fs.h>
  35 #include <linux/seq_file.h>
  36 #include <linux/export.h>
  37 #include <linux/etherdevice.h>
  38
  39 int sysctl_aarp_expiry_time = AARP_EXPIRY_TIME;
  40 int sysctl_aarp_tick_time = AARP_TICK_TIME;
  41 int sysctl_aarp_retransmit_limit = AARP_RETRANSMIT_LIMIT;
  42 int sysctl_aarp_resolve_time = AARP_RESOLVE_TIME;
  43
  44 /* Lists of aarp entries */
  45 /**
  46  *      struct aarp_entry - AARP entry
  47  *      @last_sent: Last time we xmitted the aarp request
  48  *      @packet_queue: Queue of frames wait for resolution
  49  *      @status: Used for proxy AARP
  50  *      @expires_at: Entry expiry time
  51  *      @target_addr: DDP Address
  52  *      @dev:  Device to use
  53  *      @hwaddr:  Physical i/f address of target/router
  54  *      @xmit_count:  When this hits 10 we give up
  55  *      @next: Next entry in chain
  56  */
  57 struct aarp_entry {
  58         /* These first two are only used for unresolved entries */
  59         unsigned long           last_sent;
  60         struct sk_buff_head     packet_queue;
  61         int                     status;
  62         unsigned long           expires_at;
  63         struct atalk_addr       target_addr;
  64         struct net_device       *dev;
  65         char                    hwaddr[ETH_ALEN];
  66         unsigned short          xmit_count;
  67         struct aarp_entry       *next;
  68 };
  69
  70 /* Hashed list of resolved, unresolved and proxy entries */
  71 static struct aarp_entry *resolved[AARP_HASH_SIZE];
  72 static struct aarp_entry *unresolved[AARP_HASH_SIZE];
  73 static struct aarp_entry *proxies[AARP_HASH_SIZE];
  74 static int unresolved_count;
  75
  76 /* One lock protects it all. */
  77 static DEFINE_RWLOCK(aarp_lock);
  78
  79 /* Used to walk the list and purge/kick entries.  */
  80 static struct timer_list aarp_timer;
  81
  82 /*
  83  *      Delete an aarp queue
  84  *
  85  *      Must run under aarp_lock.
  86  */
  87 static void __aarp_expire(struct aarp_entry *a)
  88 {
  89         skb_queue_purge(&a->packet_queue);
  90         kfree(a);
  91 }
  92
  93 /*
  94  *      Send an aarp queue entry request
  95  *
  96  *      Must run under aarp_lock.
  97  */
  98 static void __aarp_send_query(struct aarp_entry *a)
  99 {
 100         static unsigned char aarp_eth_multicast[ETH_ALEN] =
 101                                         { 0x09, 0x00, 0x07, 0xFF, 0xFF, 0xFF };
 102         struct net_device *dev = a->dev;
 103         struct elapaarp *eah;
 104         int len = dev->hard_header_len + sizeof(*eah) + aarp_dl->header_length;
 105         struct sk_buff *skb = alloc_skb(len, GFP_ATOMIC);
 106         struct atalk_addr *sat = atalk_find_dev_addr(dev);
 107
 108         if (!skb)
 109                 return;
 110
 111         if (!sat) {
 112                 kfree_skb(skb);
 113                 return;
 114         }
 115
 116         /* Set up the buffer */
 117         skb_reserve(skb, dev->hard_header_len + aarp_dl->header_length);
 118         skb_reset_network_header(skb);
 119         skb_reset_transport_header(skb);
 120         skb_put(skb, sizeof(*eah));
 121         skb->protocol    = htons(ETH_P_ATALK);
 122         skb->dev         = dev;
 123         eah              = aarp_hdr(skb);
 124
 125         /* Set up the ARP */
 126         eah->hw_type     = htons(AARP_HW_TYPE_ETHERNET);
 127         eah->pa_type     = htons(ETH_P_ATALK);
 128         eah->hw_len      = ETH_ALEN;
 129         eah->pa_len      = AARP_PA_ALEN;
 130         eah->function    = htons(AARP_REQUEST);
 131
 132         ether_addr_copy(eah->hw_src, dev->dev_addr);
 133
 134         eah->pa_src_zero = 0;
 135         eah->pa_src_net  = sat->s_net;
 136         eah->pa_src_node = sat->s_node;
 137
 138         eth_zero_addr(eah->hw_dst);
 139
 140         eah->pa_dst_zero = 0;
 141         eah->pa_dst_net  = a->target_addr.s_net;
 142         eah->pa_dst_node = a->target_addr.s_node;
 143
 144         /* Send it */
 145         aarp_dl->request(aarp_dl, skb, aarp_eth_multicast);
 146         /* Update the sending count */
 147         a->xmit_count++;
 148         a->last_sent = jiffies;
 149 }
 150
 151 /* This runs under aarp_lock and in softint context, so only atomic memory
 152  * allocations can be used. */
 153 static void aarp_send_reply(struct net_device *dev, struct atalk_addr *us,
 154                             struct atalk_addr *them, unsigned char *sha)
 155 {
 156         struct elapaarp *eah;
 157         int len = dev->hard_header_len + sizeof(*eah) + aarp_dl->header_length;
 158         struct sk_buff *skb = alloc_skb(len, GFP_ATOMIC);
 159
 160         if (!skb)
 161                 return;
 162
 163         /* Set up the buffer */
 164         skb_reserve(skb, dev->hard_header_len + aarp_dl->header_length);
 165         skb_reset_network_header(skb);
 166         skb_reset_transport_header(skb);
 167         skb_put(skb, sizeof(*eah));
 168         skb->protocol    = htons(ETH_P_ATALK);
 169         skb->dev         = dev;
 170         eah              = aarp_hdr(skb);
 171
 172         /* Set up the ARP */
 173         eah->hw_type     = htons(AARP_HW_TYPE_ETHERNET);
 174         eah->pa_type     = htons(ETH_P_ATALK);
 175         eah->hw_len      = ETH_ALEN;
 176         eah->pa_len      = AARP_PA_ALEN;
 177         eah->function    = htons(AARP_REPLY);
 178
 179         ether_addr_copy(eah->hw_src, dev->dev_addr);
 180
 181         eah->pa_src_zero = 0;
 182         eah->pa_src_net  = us->s_net;
 183         eah->pa_src_node = us->s_node;
 184
 185         if (!sha)
 186                 eth_zero_addr(eah->hw_dst);
 187         else
 188                 ether_addr_copy(eah->hw_dst, sha);
 189
 190         eah->pa_dst_zero = 0;
 191         eah->pa_dst_net  = them->s_net;
 192         eah->pa_dst_node = them->s_node;
 193
 194         /* Send it */
 195         aarp_dl->request(aarp_dl, skb, sha);
 196 }
 197
 198 /*
 199  *      Send probe frames. Called from aarp_probe_network and
 200  *      aarp_proxy_probe_network.
 201  */
 202
 203 static void aarp_send_probe(struct net_device *dev, struct atalk_addr *us)
 204 {
 205         struct elapaarp *eah;
 206         int len = dev->hard_header_len + sizeof(*eah) + aarp_dl->header_length;
 207         struct sk_buff *skb = alloc_skb(len, GFP_ATOMIC);
 208         static unsigned char aarp_eth_multicast[ETH_ALEN] =
 209                                         { 0x09, 0x00, 0x07, 0xFF, 0xFF, 0xFF };
 210
 211         if (!skb)
 212                 return;
 213
 214         /* Set up the buffer */
 215         skb_reserve(skb, dev->hard_header_len + aarp_dl->header_length);
 216         skb_reset_network_header(skb);
 217         skb_reset_transport_header(skb);
 218         skb_put(skb, sizeof(*eah));
 219         skb->protocol    = htons(ETH_P_ATALK);
 220         skb->dev         = dev;
 221         eah              = aarp_hdr(skb);
 222
 223         /* Set up the ARP */
 224         eah->hw_type     = htons(AARP_HW_TYPE_ETHERNET);
 225         eah->pa_type     = htons(ETH_P_ATALK);
 226         eah->hw_len      = ETH_ALEN;
 227         eah->pa_len      = AARP_PA_ALEN;
 228         eah->function    = htons(AARP_PROBE);
 229
 230         ether_addr_copy(eah->hw_src, dev->dev_addr);
 231
 232         eah->pa_src_zero = 0;
 233         eah->pa_src_net  = us->s_net;
 234         eah->pa_src_node = us->s_node;
 235
 236         eth_zero_addr(eah->hw_dst);
 237
 238         eah->pa_dst_zero = 0;
 239         eah->pa_dst_net  = us->s_net;
 240         eah->pa_dst_node = us->s_node;
 241
 242         /* Send it */
 243         aarp_dl->request(aarp_dl, skb, aarp_eth_multicast);
 244 }
 245
 246 /*
 247  *      Handle an aarp timer expire
 248  *
 249  *      Must run under the aarp_lock.
 250  */
 251
 252 static void __aarp_expire_timer(struct aarp_entry **n)
 253 {
 254         struct aarp_entry *t;
 255
 256         while (*n)
 257                 /* Expired ? */
 258                 if (time_after(jiffies, (*n)->expires_at)) {
 259                         t = *n;
 260                         *n = (*n)->next;
 261                         __aarp_expire(t);
 262                 } else
 263                         n = &((*n)->next);
 264 }
 265
 266 /*
 267  *      Kick all pending requests 5 times a second.
 268  *
 269  *      Must run under the aarp_lock.
 270  */
 271 static void __aarp_kick(struct aarp_entry **n)
 272 {
 273         struct aarp_entry *t;
 274
 275         while (*n)
 276                 /* Expired: if this will be the 11th tx, we delete instead. */
 277                 if ((*n)->xmit_count >= sysctl_aarp_retransmit_limit) {
 278                         t = *n;
 279                         *n = (*n)->next;
 280                         __aarp_expire(t);
 281                 } else {
 282                         __aarp_send_query(*n);
 283                         n = &((*n)->next);
 284                 }
 285 }
 286
 287 /*
 288  *      A device has gone down. Take all entries referring to the device
 289  *      and remove them.
 290  *
 291  *      Must run under the aarp_lock.
 292  */
 293 static void __aarp_expire_device(struct aarp_entry **n, struct net_device *dev)
 294 {
 295         struct aarp_entry *t;
 296
 297         while (*n)
 298                 if ((*n)->dev == dev) {
 299                         t = *n;
 300                         *n = (*n)->next;
 301                         __aarp_expire(t);
 302                 } else
 303                         n = &((*n)->next);
 304 }
 305
 306 /* Handle the timer event */
 307 static void aarp_expire_timeout(struct timer_list *unused)
 308 {
 309         int ct;
 310
 311         write_lock_bh(&aarp_lock);
 312
 313         for (ct = 0; ct < AARP_HASH_SIZE; ct++) {
 314                 __aarp_expire_timer(&resolved[ct]);
 315                 __aarp_kick(&unresolved[ct]);
 316                 __aarp_expire_timer(&unresolved[ct]);
 317                 __aarp_expire_timer(&proxies[ct]);
 318         }
 319
 320         write_unlock_bh(&aarp_lock);
 321         mod_timer(&aarp_timer, jiffies +
 322                                (unresolved_count ? sysctl_aarp_tick_time :
 323                                 sysctl_aarp_expiry_time));
 324 }
 325
 326 /* Network device notifier chain handler. */
 327 static int aarp_device_event(struct notifier_block *this, unsigned long event,
 328                              void *ptr)
 329 {
 330         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 331         int ct;
 332
 333         if (!net_eq(dev_net(dev), &init_net))
 334                 return NOTIFY_DONE;
 335
 336         if (event == NETDEV_DOWN) {
 337                 write_lock_bh(&aarp_lock);
 338
 339                 for (ct = 0; ct < AARP_HASH_SIZE; ct++) {
 340                         __aarp_expire_device(&resolved[ct], dev);
 341                         __aarp_expire_device(&unresolved[ct], dev);
 342                         __aarp_expire_device(&proxies[ct], dev);
 343                 }
 344
 345                 write_unlock_bh(&aarp_lock);
 346         }
 347         return NOTIFY_DONE;
 348 }
 349
 350 /* Expire all entries in a hash chain */
 351 static void __aarp_expire_all(struct aarp_entry **n)
 352 {
 353         struct aarp_entry *t;
 354
 355         while (*n) {
 356                 t = *n;
 357                 *n = (*n)->next;
 358                 __aarp_expire(t);
 359         }
 360 }
 361
 362 /* Cleanup all hash chains -- module unloading */
 363 static void aarp_purge(void)
 364 {
 365         int ct;
 366
 367         write_lock_bh(&aarp_lock);
 368         for (ct = 0; ct < AARP_HASH_SIZE; ct++) {
 369                 __aarp_expire_all(&resolved[ct]);
 370                 __aarp_expire_all(&unresolved[ct]);
 371                 __aarp_expire_all(&proxies[ct]);
 372         }
 373         write_unlock_bh(&aarp_lock);
 374 }
 375
 376 /*
 377  *      Create a new aarp entry.  This must use GFP_ATOMIC because it
 378  *      runs while holding spinlocks.
 379  */
 380 static struct aarp_entry *aarp_alloc(void)
 381 {
 382         struct aarp_entry *a = kmalloc(sizeof(*a), GFP_ATOMIC);
 383
 384         if (a)
 385                 skb_queue_head_init(&a->packet_queue);
 386         return a;
 387 }
 388
 389 /*
 390  * Find an entry. We might return an expired but not yet purged entry. We
 391  * don't care as it will do no harm.
 392  *
 393  * This must run under the aarp_lock.
 394  */
 395 static struct aarp_entry *__aarp_find_entry(struct aarp_entry *list,
 396                                             struct net_device *dev,
 397                                             struct atalk_addr *sat)
 398 {
 399         while (list) {
 400                 if (list->target_addr.s_net == sat->s_net &&
 401                     list->target_addr.s_node == sat->s_node &&
 402                     list->dev == dev)
 403                         break;
 404                 list = list->next;
 405         }
 406
 407         return list;
 408 }
 409
 410 /* Called from the DDP code, and thus must be exported. */
 411 void aarp_proxy_remove(struct net_device *dev, struct atalk_addr *sa)
 412 {
 413         int hash = sa->s_node % (AARP_HASH_SIZE - 1);
 414         struct aarp_entry *a;
 415
 416         write_lock_bh(&aarp_lock);
 417
 418         a = __aarp_find_entry(proxies[hash], dev, sa);
 419         if (a)
 420                 a->expires_at = jiffies - 1;
 421
 422         write_unlock_bh(&aarp_lock);
 423 }
 424
 425 /* This must run under aarp_lock. */
 426 static struct atalk_addr *__aarp_proxy_find(struct net_device *dev,
 427                                             struct atalk_addr *sa)
 428 {
 429         int hash = sa->s_node % (AARP_HASH_SIZE - 1);
 430         struct aarp_entry *a = __aarp_find_entry(proxies[hash], dev, sa);
 431
 432         return a ? sa : NULL;
 433 }
 434
 435 /*
 436  * Probe a Phase 1 device or a device that requires its Net:Node to
 437  * be set via an ioctl.
 438  */
 439 static void aarp_send_probe_phase1(struct atalk_iface *iface)
 440 {
 441         struct ifreq atreq;
 442         struct sockaddr_at *sa = (struct sockaddr_at *)&atreq.ifr_addr;
 443         const struct net_device_ops *ops = iface->dev->netdev_ops;
 444
 445         sa->sat_addr.s_node = iface->address.s_node;
 446         sa->sat_addr.s_net = ntohs(iface->address.s_net);
 447
 448         /* We pass the Net:Node to the drivers/cards by a Device ioctl. */
 449         if (!(ops->ndo_do_ioctl(iface->dev, &atreq, SIOCSIFADDR))) {
 450                 ops->ndo_do_ioctl(iface->dev, &atreq, SIOCGIFADDR);
 451                 if (iface->address.s_net != htons(sa->sat_addr.s_net) ||
 452                     iface->address.s_node != sa->sat_addr.s_node)
 453                         iface->status |= ATIF_PROBE_FAIL;
 454
 455                 iface->address.s_net  = htons(sa->sat_addr.s_net);
 456                 iface->address.s_node = sa->sat_addr.s_node;
 457         }
 458 }
 459
 460
 461 void aarp_probe_network(struct atalk_iface *atif)
 462 {
 463         if (atif->dev->type == ARPHRD_LOCALTLK ||
 464             atif->dev->type == ARPHRD_PPP)
 465                 aarp_send_probe_phase1(atif);
 466         else {
 467                 unsigned int count;
 468
 469                 for (count = 0; count < AARP_RETRANSMIT_LIMIT; count++) {
 470                         aarp_send_probe(atif->dev, &atif->address);
 471
 472                         /* Defer 1/10th */
 473                         msleep(100);
 474
 475                         if (atif->status & ATIF_PROBE_FAIL)
 476                                 break;
 477                 }
 478         }
 479 }
 480
 481 int aarp_proxy_probe_network(struct atalk_iface *atif, struct atalk_addr *sa)
 482 {
 483         int hash, retval = -EPROTONOSUPPORT;
 484         struct aarp_entry *entry;
 485         unsigned int count;
 486
 487         /*
 488          * we don't currently support LocalTalk or PPP for proxy AARP;
 489          * if someone wants to try and add it, have fun
 490          */
 491         if (atif->dev->type == ARPHRD_LOCALTLK ||
 492             atif->dev->type == ARPHRD_PPP)
 493                 goto out;
 494
 495         /*
 496          * create a new AARP entry with the flags set to be published --
 497          * we need this one to hang around even if it's in use
 498          */
 499         entry = aarp_alloc();
 500         retval = -ENOMEM;
 501         if (!entry)
 502                 goto out;
 503
 504         entry->expires_at = -1;
 505         entry->status = ATIF_PROBE;
 506         entry->target_addr.s_node = sa->s_node;
 507         entry->target_addr.s_net = sa->s_net;
 508         entry->dev = atif->dev;
 509
 510         write_lock_bh(&aarp_lock);
 511
 512         hash = sa->s_node % (AARP_HASH_SIZE - 1);
 513         entry->next = proxies[hash];
 514         proxies[hash] = entry;
 515
 516         for (count = 0; count < AARP_RETRANSMIT_LIMIT; count++) {
 517                 aarp_send_probe(atif->dev, sa);
 518
 519                 /* Defer 1/10th */
 520                 write_unlock_bh(&aarp_lock);
 521                 msleep(100);
 522                 write_lock_bh(&aarp_lock);
 523
 524                 if (entry->status & ATIF_PROBE_FAIL)
 525                         break;
 526         }
 527
 528         if (entry->status & ATIF_PROBE_FAIL) {
 529                 entry->expires_at = jiffies - 1; /* free the entry */
 530                 retval = -EADDRINUSE; /* return network full */
 531         } else { /* clear the probing flag */
 532                 entry->status &= ~ATIF_PROBE;
 533                 retval = 1;
 534         }
 535
 536         write_unlock_bh(&aarp_lock);
 537 out:
 538         return retval;
 539 }
 540
 541 /* Send a DDP frame */
 542 int aarp_send_ddp(struct net_device *dev, struct sk_buff *skb,
 543                   struct atalk_addr *sa, void *hwaddr)
 544 {
 545         static char ddp_eth_multicast[ETH_ALEN] =
 546                 { 0x09, 0x00, 0x07, 0xFF, 0xFF, 0xFF };
 547         int hash;
 548         struct aarp_entry *a;
 549
 550         skb_reset_network_header(skb);
 551
 552         /* Check for LocalTalk first */
 553         if (dev->type == ARPHRD_LOCALTLK) {
 554                 struct atalk_addr *at = atalk_find_dev_addr(dev);
 555                 struct ddpehdr *ddp = (struct ddpehdr *)skb->data;
 556                 int ft = 2;
 557
 558                 /*
 559                  * Compressible ?
 560                  *
 561                  * IFF: src_net == dest_net == device_net
 562                  * (zero matches anything)
 563                  */
 564
 565                 if ((!ddp->deh_snet || at->s_net == ddp->deh_snet) &&
 566                     (!ddp->deh_dnet || at->s_net == ddp->deh_dnet)) {
 567                         skb_pull(skb, sizeof(*ddp) - 4);
 568
 569                         /*
 570                          *      The upper two remaining bytes are the port
 571                          *      numbers we just happen to need. Now put the
 572                          *      length in the lower two.
 573                          */
 574                         *((__be16 *)skb->data) = htons(skb->len);
 575                         ft = 1;
 576                 }
 577                 /*
 578                  * Nice and easy. No AARP type protocols occur here so we can
 579                  * just shovel it out with a 3 byte LLAP header
 580                  */
 581
 582                 skb_push(skb, 3);
 583                 skb->data[0] = sa->s_node;
 584                 skb->data[1] = at->s_node;
 585                 skb->data[2] = ft;
 586                 skb->dev     = dev;
 587                 goto sendit;
 588         }
 589
 590         /* On a PPP link we neither compress nor aarp.  */
 591         if (dev->type == ARPHRD_PPP) {
 592                 skb->protocol = htons(ETH_P_PPPTALK);
 593                 skb->dev = dev;
 594                 goto sendit;
 595         }
 596
 597         /* Non ELAP we cannot do. */
 598         if (dev->type != ARPHRD_ETHER)
 599                 goto free_it;
 600
 601         skb->dev = dev;
 602         skb->protocol = htons(ETH_P_ATALK);
 603         hash = sa->s_node % (AARP_HASH_SIZE - 1);
 604
 605         /* Do we have a resolved entry? */
 606         if (sa->s_node == ATADDR_BCAST) {
 607                 /* Send it */
 608                 ddp_dl->request(ddp_dl, skb, ddp_eth_multicast);
 609                 goto sent;
 610         }
 611
 612         write_lock_bh(&aarp_lock);
 613         a = __aarp_find_entry(resolved[hash], dev, sa);
 614
 615         if (a) { /* Return 1 and fill in the address */
 616                 a->expires_at = jiffies + (sysctl_aarp_expiry_time * 10);
 617                 ddp_dl->request(ddp_dl, skb, a->hwaddr);
 618                 write_unlock_bh(&aarp_lock);
 619                 goto sent;
 620         }
 621
 622         /* Do we have an unresolved entry: This is the less common path */
 623         a = __aarp_find_entry(unresolved[hash], dev, sa);
 624         if (a) { /* Queue onto the unresolved queue */
 625                 skb_queue_tail(&a->packet_queue, skb);
 626                 goto out_unlock;
 627         }
 628
 629         /* Allocate a new entry */
 630         a = aarp_alloc();
 631         if (!a) {
 632                 /* Whoops slipped... good job it's an unreliable protocol 8) */
 633                 write_unlock_bh(&aarp_lock);
 634                 goto free_it;
 635         }
 636
 637         /* Set up the queue */
 638         skb_queue_tail(&a->packet_queue, skb);
 639         a->expires_at    = jiffies + sysctl_aarp_resolve_time;
 640         a->dev           = dev;
 641         a->next          = unresolved[hash];
 642         a->target_addr   = *sa;
 643         a->xmit_count    = 0;
 644         unresolved[hash] = a;
 645         unresolved_count++;
 646
 647         /* Send an initial request for the address */
 648         __aarp_send_query(a);
 649
 650         /*
 651          * Switch to fast timer if needed (That is if this is the first
 652          * unresolved entry to get added)
 653          */
 654
 655         if (unresolved_count == 1)
 656                 mod_timer(&aarp_timer, jiffies + sysctl_aarp_tick_time);
 657
 658         /* Now finally, it is safe to drop the lock. */
 659 out_unlock:
 660         write_unlock_bh(&aarp_lock);
 661
 662         /* Tell the ddp layer we have taken over for this frame. */
 663         goto sent;
 664
 665 sendit:
 666         if (skb->sk)
 667                 skb->priority = READ_ONCE(skb->sk->sk_priority);
 668         if (dev_queue_xmit(skb))
 669                 goto drop;
 670 sent:
 671         return NET_XMIT_SUCCESS;
 672 free_it:
 673         kfree_skb(skb);
 674 drop:
 675         return NET_XMIT_DROP;
 676 }
 677 EXPORT_SYMBOL(aarp_send_ddp);
 678
 679 /*
 680  *      An entry in the aarp unresolved queue has become resolved. Send
 681  *      all the frames queued under it.
 682  *
 683  *      Must run under aarp_lock.
 684  */
 685 static void __aarp_resolved(struct aarp_entry **list, struct aarp_entry *a,
 686                             int hash)
 687 {
 688         struct sk_buff *skb;
 689
 690         while (*list)
 691                 if (*list == a) {
 692                         unresolved_count--;
 693                         *list = a->next;
 694
 695                         /* Move into the resolved list */
 696                         a->next = resolved[hash];
 697                         resolved[hash] = a;
 698
 699                         /* Kick frames off */
 700                         while ((skb = skb_dequeue(&a->packet_queue)) != NULL) {
 701                                 a->expires_at = jiffies +
 702                                                 sysctl_aarp_expiry_time * 10;
 703                                 ddp_dl->request(ddp_dl, skb, a->hwaddr);
 704                         }
 705                 } else
 706                         list = &((*list)->next);
 707 }
 708
 709 /*
 710  *      This is called by the SNAP driver whenever we see an AARP SNAP
 711  *      frame. We currently only support Ethernet.
 712  */
 713 static int aarp_rcv(struct sk_buff *skb, struct net_device *dev,
 714                     struct packet_type *pt, struct net_device *orig_dev)
 715 {
 716         struct elapaarp *ea = aarp_hdr(skb);
 717         int hash, ret = 0;
 718         __u16 function;
 719         struct aarp_entry *a;
 720         struct atalk_addr sa, *ma, da;
 721         struct atalk_iface *ifa;
 722
 723         if (!net_eq(dev_net(dev), &init_net))
 724                 goto out0;
 725
 726         /* We only do Ethernet SNAP AARP. */
 727         if (dev->type != ARPHRD_ETHER)
 728                 goto out0;
 729
 730         /* Frame size ok? */
 731         if (!skb_pull(skb, sizeof(*ea)))
 732                 goto out0;
 733
 734         function = ntohs(ea->function);
 735
 736         /* Sanity check fields. */
 737         if (function < AARP_REQUEST || function > AARP_PROBE ||
 738             ea->hw_len != ETH_ALEN || ea->pa_len != AARP_PA_ALEN ||
 739             ea->pa_src_zero || ea->pa_dst_zero)
 740                 goto out0;
 741
 742         /* Looks good. */
 743         hash = ea->pa_src_node % (AARP_HASH_SIZE - 1);
 744
 745         /* Build an address. */
 746         sa.s_node = ea->pa_src_node;
 747         sa.s_net = ea->pa_src_net;
 748
 749         /* Process the packet. Check for replies of me. */
 750         ifa = atalk_find_dev(dev);
 751         if (!ifa)
 752                 goto out1;
 753
 754         if (ifa->status & ATIF_PROBE &&
 755             ifa->address.s_node == ea->pa_dst_node &&
 756             ifa->address.s_net == ea->pa_dst_net) {
 757                 ifa->status |= ATIF_PROBE_FAIL; /* Fail the probe (in use) */
 758                 goto out1;
 759         }
 760
 761         /* Check for replies of proxy AARP entries */
 762         da.s_node = ea->pa_dst_node;
 763         da.s_net  = ea->pa_dst_net;
 764
 765         write_lock_bh(&aarp_lock);
 766         a = __aarp_find_entry(proxies[hash], dev, &da);
 767
 768         if (a && a->status & ATIF_PROBE) {
 769                 a->status |= ATIF_PROBE_FAIL;
 770                 /*
 771                  * we do not respond to probe or request packets of
 772                  * this address while we are probing this address
 773                  */
 774                 goto unlock;
 775         }
 776
 777         switch (function) {
 778         case AARP_REPLY:
 779                 if (!unresolved_count)  /* Speed up */
 780                         break;
 781
 782                 /* Find the entry.  */
 783                 a = __aarp_find_entry(unresolved[hash], dev, &sa);
 784                 if (!a || dev != a->dev)
 785                         break;
 786
 787                 /* We can fill one in - this is good. */
 788                 ether_addr_copy(a->hwaddr, ea->hw_src);
 789                 __aarp_resolved(&unresolved[hash], a, hash);
 790                 if (!unresolved_count)
 791                         mod_timer(&aarp_timer,
 792                                   jiffies + sysctl_aarp_expiry_time);
 793                 break;
 794
 795         case AARP_REQUEST:
 796         case AARP_PROBE:
 797
 798                 /*
 799                  * If it is my address set ma to my address and reply.
 800                  * We can treat probe and request the same.  Probe
 801                  * simply means we shouldn't cache the querying host,
 802                  * as in a probe they are proposing an address not
 803                  * using one.
 804                  *
 805                  * Support for proxy-AARP added. We check if the
 806                  * address is one of our proxies before we toss the
 807                  * packet out.
 808                  */
 809
 810                 sa.s_node = ea->pa_dst_node;
 811                 sa.s_net  = ea->pa_dst_net;
 812
 813                 /* See if we have a matching proxy. */
 814                 ma = __aarp_proxy_find(dev, &sa);
 815                 if (!ma)
 816                         ma = &ifa->address;
 817                 else { /* We need to make a copy of the entry. */
 818                         da.s_node = sa.s_node;
 819                         da.s_net = sa.s_net;
 820                         ma = &da;
 821                 }
 822
 823                 if (function == AARP_PROBE) {
 824                         /*
 825                          * A probe implies someone trying to get an
 826                          * address. So as a precaution flush any
 827                          * entries we have for this address.
 828                          */
 829                         a = __aarp_find_entry(resolved[sa.s_node %
 830                                                        (AARP_HASH_SIZE - 1)],
 831                                               skb->dev, &sa);
 832
 833                         /*
 834                          * Make it expire next tick - that avoids us
 835                          * getting into a probe/flush/learn/probe/
 836                          * flush/learn cycle during probing of a slow
 837                          * to respond host addr.
 838                          */
 839                         if (a) {
 840                                 a->expires_at = jiffies - 1;
 841                                 mod_timer(&aarp_timer, jiffies +
 842                                           sysctl_aarp_tick_time);
 843                         }
 844                 }
 845
 846                 if (sa.s_node != ma->s_node)
 847                         break;
 848
 849                 if (sa.s_net && ma->s_net && sa.s_net != ma->s_net)
 850                         break;
 851
 852                 sa.s_node = ea->pa_src_node;
 853                 sa.s_net = ea->pa_src_net;
 854
 855                 /* aarp_my_address has found the address to use for us.
 856                  */
 857                 aarp_send_reply(dev, ma, &sa, ea->hw_src);
 858                 break;
 859         }
 860
 861 unlock:
 862         write_unlock_bh(&aarp_lock);
 863 out1:
 864         ret = 1;
 865 out0:
 866         kfree_skb(skb);
 867         return ret;
 868 }
 869
 870 static struct notifier_block aarp_notifier = {
 871         .notifier_call = aarp_device_event,
 872 };
 873
 874 static unsigned char aarp_snap_id[] = { 0x00, 0x00, 0x00, 0x80, 0xF3 };
 875
 876 int __init aarp_proto_init(void)
 877 {
 878         int rc;
 879
 880         aarp_dl = register_snap_client(aarp_snap_id, aarp_rcv);
 881         if (!aarp_dl) {
 882                 printk(KERN_CRIT "Unable to register AARP with SNAP.\n");
 883                 return -ENOMEM;
 884         }
 885         timer_setup(&aarp_timer, aarp_expire_timeout, 0);
 886         aarp_timer.expires  = jiffies + sysctl_aarp_expiry_time;
 887         add_timer(&aarp_timer);
 888         rc = register_netdevice_notifier(&aarp_notifier);
 889         if (rc) {
 890                 del_timer_sync(&aarp_timer);
 891                 unregister_snap_client(aarp_dl);
 892         }
 893         return rc;
 894 }
 895
 896 /* Remove the AARP entries associated with a device. */
 897 void aarp_device_down(struct net_device *dev)
 898 {
 899         int ct;
 900
 901         write_lock_bh(&aarp_lock);
 902
 903         for (ct = 0; ct < AARP_HASH_SIZE; ct++) {
 904                 __aarp_expire_device(&resolved[ct], dev);
 905                 __aarp_expire_device(&unresolved[ct], dev);
 906                 __aarp_expire_device(&proxies[ct], dev);
 907         }
 908
 909         write_unlock_bh(&aarp_lock);
 910 }
 911
 912 #ifdef CONFIG_PROC_FS
 913 /*
 914  * Get the aarp entry that is in the chain described
 915  * by the iterator.
 916  * If pos is set then skip till that index.
 917  * pos = 1 is the first entry
 918  */
 919 static struct aarp_entry *iter_next(struct aarp_iter_state *iter, loff_t *pos)
 920 {
 921         int ct = iter->bucket;
 922         struct aarp_entry **table = iter->table;
 923         loff_t off = 0;
 924         struct aarp_entry *entry;
 925
 926  rescan:
 927         while (ct < AARP_HASH_SIZE) {
 928                 for (entry = table[ct]; entry; entry = entry->next) {
 929                         if (!pos || ++off == *pos) {
 930                                 iter->table = table;
 931                                 iter->bucket = ct;
 932                                 return entry;
 933                         }
 934                 }
 935                 ++ct;
 936         }
 937
 938         if (table == resolved) {
 939                 ct = 0;
 940                 table = unresolved;
 941                 goto rescan;
 942         }
 943         if (table == unresolved) {
 944                 ct = 0;
 945                 table = proxies;
 946                 goto rescan;
 947         }
 948         return NULL;
 949 }
 950
 951 static void *aarp_seq_start(struct seq_file *seq, loff_t *pos)
 952         __acquires(aarp_lock)
 953 {
 954         struct aarp_iter_state *iter = seq->private;
 955
 956         read_lock_bh(&aarp_lock);
 957         iter->table     = resolved;
 958         iter->bucket    = 0;
 959
 960         return *pos ? iter_next(iter, pos) : SEQ_START_TOKEN;
 961 }
 962
 963 static void *aarp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 964 {
 965         struct aarp_entry *entry = v;
 966         struct aarp_iter_state *iter = seq->private;
 967
 968         ++*pos;
 969
 970         /* first line after header */
 971         if (v == SEQ_START_TOKEN)
 972                 entry = iter_next(iter, NULL);
 973
 974         /* next entry in current bucket */
 975         else if (entry->next)
 976                 entry = entry->next;
 977
 978         /* next bucket or table */
 979         else {
 980                 ++iter->bucket;
 981                 entry = iter_next(iter, NULL);
 982         }
 983         return entry;
 984 }
 985
 986 static void aarp_seq_stop(struct seq_file *seq, void *v)
 987         __releases(aarp_lock)
 988 {
 989         read_unlock_bh(&aarp_lock);
 990 }
 991
 992 static const char *dt2str(unsigned long ticks)
 993 {
 994         static char buf[32];
 995
 996         sprintf(buf, "%ld.%02ld", ticks / HZ, ((ticks % HZ) * 100) / HZ);
 997
 998         return buf;
 999 }
1000
1001 static int aarp_seq_show(struct seq_file *seq, void *v)
1002 {
1003         struct aarp_iter_state *iter = seq->private;
1004         struct aarp_entry *entry = v;
1005         unsigned long now = jiffies;
1006
1007         if (v == SEQ_START_TOKEN)
1008                 seq_puts(seq,
1009                          "Address  Interface   Hardware Address"
1010                          "   Expires LastSend  Retry Status\n");
1011         else {
1012                 seq_printf(seq, "%04X:%02X  %-12s",
1013                            ntohs(entry->target_addr.s_net),
1014                            (unsigned int) entry->target_addr.s_node,
1015                            entry->dev ? entry->dev->name : "????");
1016                 seq_printf(seq, "%pM", entry->hwaddr);
1017                 seq_printf(seq, " %8s",
1018                            dt2str((long)entry->expires_at - (long)now));
1019                 if (iter->table == unresolved)
1020                         seq_printf(seq, " %8s %6hu",
1021                                    dt2str(now - entry->last_sent),
1022                                    entry->xmit_count);
1023                 else
1024                         seq_puts(seq, "                ");
1025                 seq_printf(seq, " %s\n",
1026                            (iter->table == resolved) ? "resolved"
1027                            : (iter->table == unresolved) ? "unresolved"
1028                            : (iter->table == proxies) ? "proxies"
1029                            : "unknown");
1030         }
1031         return 0;
1032 }
1033
1034 const struct seq_operations aarp_seq_ops = {
1035         .start  = aarp_seq_start,
1036         .next   = aarp_seq_next,
1037         .stop   = aarp_seq_stop,
1038         .show   = aarp_seq_show,
1039 };
1040 #endif
1041
1042 /* General module cleanup. Called from cleanup_module() in ddp.c. */
1043 void aarp_cleanup_module(void)
1044 {
1045         del_timer_sync(&aarp_timer);
1046         unregister_netdevice_notifier(&aarp_notifier);
1047         unregister_snap_client(aarp_dl);
1048         aarp_purge();
1049 }