~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/appletalk/aarp.c

Version: ~ [ linux-5.11-rc3 ] ~ [ linux-5.10.7 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.89 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.167 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.215 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.251 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.251 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 = 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 for
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 }
1050 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp