12874c5fdSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
21da177e4SLinus Torvalds /*
31da177e4SLinus Torvalds * AARP: An implementation of the AppleTalk AARP protocol for
41da177e4SLinus Torvalds * Ethernet 'ELAP'.
51da177e4SLinus Torvalds *
61da177e4SLinus Torvalds * Alan Cox <Alan.Cox@linux.org>
71da177e4SLinus Torvalds *
81da177e4SLinus Torvalds * This doesn't fit cleanly with the IP arp. Potentially we can use
91da177e4SLinus Torvalds * the generic neighbour discovery code to clean this up.
101da177e4SLinus Torvalds *
111da177e4SLinus Torvalds * FIXME:
121da177e4SLinus Torvalds * We ought to handle the retransmits with a single list and a
131da177e4SLinus Torvalds * separate fast timer for when it is needed.
141da177e4SLinus Torvalds * Use neighbour discovery code.
151da177e4SLinus Torvalds * Token Ring Support.
161da177e4SLinus Torvalds *
171da177e4SLinus Torvalds * References:
181da177e4SLinus Torvalds * Inside AppleTalk (2nd Ed).
191da177e4SLinus Torvalds * Fixes:
201da177e4SLinus Torvalds * Jaume Grau - flush caches on AARP_PROBE
211da177e4SLinus Torvalds * Rob Newberry - Added proxy AARP and AARP proc fs,
221da177e4SLinus Torvalds * moved probing from DDP module.
231da177e4SLinus Torvalds * Arnaldo C. Melo - don't mangle rx packets
241da177e4SLinus Torvalds */
251da177e4SLinus Torvalds
261da177e4SLinus Torvalds #include <linux/if_arp.h>
275a0e3ad6STejun Heo #include <linux/slab.h>
281da177e4SLinus Torvalds #include <net/sock.h>
291da177e4SLinus Torvalds #include <net/datalink.h>
301da177e4SLinus Torvalds #include <net/psnap.h>
311da177e4SLinus Torvalds #include <linux/atalk.h>
32285b3afeSNishanth Aravamudan #include <linux/delay.h>
331da177e4SLinus Torvalds #include <linux/init.h>
341da177e4SLinus Torvalds #include <linux/proc_fs.h>
351da177e4SLinus Torvalds #include <linux/seq_file.h>
36bc3b2d7fSPaul Gortmaker #include <linux/export.h>
379be68c1aSDavid S. Miller #include <linux/etherdevice.h>
381da177e4SLinus Torvalds
391da177e4SLinus Torvalds int sysctl_aarp_expiry_time = AARP_EXPIRY_TIME;
401da177e4SLinus Torvalds int sysctl_aarp_tick_time = AARP_TICK_TIME;
411da177e4SLinus Torvalds int sysctl_aarp_retransmit_limit = AARP_RETRANSMIT_LIMIT;
421da177e4SLinus Torvalds int sysctl_aarp_resolve_time = AARP_RESOLVE_TIME;
431da177e4SLinus Torvalds
441da177e4SLinus Torvalds /* Lists of aarp entries */
451da177e4SLinus Torvalds /**
461da177e4SLinus Torvalds * struct aarp_entry - AARP entry
47709565aeSAndrew Lunn * @last_sent: Last time we xmitted the aarp request
48709565aeSAndrew Lunn * @packet_queue: Queue of frames wait for resolution
49709565aeSAndrew Lunn * @status: Used for proxy AARP
50709565aeSAndrew Lunn * @expires_at: Entry expiry time
51709565aeSAndrew Lunn * @target_addr: DDP Address
52709565aeSAndrew Lunn * @dev: Device to use
53709565aeSAndrew Lunn * @hwaddr: Physical i/f address of target/router
54709565aeSAndrew Lunn * @xmit_count: When this hits 10 we give up
55709565aeSAndrew Lunn * @next: Next entry in chain
561da177e4SLinus Torvalds */
571da177e4SLinus Torvalds struct aarp_entry {
581da177e4SLinus Torvalds /* These first two are only used for unresolved entries */
591da177e4SLinus Torvalds unsigned long last_sent;
601da177e4SLinus Torvalds struct sk_buff_head packet_queue;
611da177e4SLinus Torvalds int status;
621da177e4SLinus Torvalds unsigned long expires_at;
631da177e4SLinus Torvalds struct atalk_addr target_addr;
641da177e4SLinus Torvalds struct net_device *dev;
6590ccb6aaSJoe Perches char hwaddr[ETH_ALEN];
661da177e4SLinus Torvalds unsigned short xmit_count;
671da177e4SLinus Torvalds struct aarp_entry *next;
681da177e4SLinus Torvalds };
691da177e4SLinus Torvalds
701da177e4SLinus Torvalds /* Hashed list of resolved, unresolved and proxy entries */
711da177e4SLinus Torvalds static struct aarp_entry *resolved[AARP_HASH_SIZE];
721da177e4SLinus Torvalds static struct aarp_entry *unresolved[AARP_HASH_SIZE];
731da177e4SLinus Torvalds static struct aarp_entry *proxies[AARP_HASH_SIZE];
741da177e4SLinus Torvalds static int unresolved_count;
751da177e4SLinus Torvalds
761da177e4SLinus Torvalds /* One lock protects it all. */
771da177e4SLinus Torvalds static DEFINE_RWLOCK(aarp_lock);
781da177e4SLinus Torvalds
791da177e4SLinus Torvalds /* Used to walk the list and purge/kick entries. */
801da177e4SLinus Torvalds static struct timer_list aarp_timer;
811da177e4SLinus Torvalds
821da177e4SLinus Torvalds /*
831da177e4SLinus Torvalds * Delete an aarp queue
841da177e4SLinus Torvalds *
851da177e4SLinus Torvalds * Must run under aarp_lock.
861da177e4SLinus Torvalds */
__aarp_expire(struct aarp_entry * a)871da177e4SLinus Torvalds static void __aarp_expire(struct aarp_entry *a)
881da177e4SLinus Torvalds {
891da177e4SLinus Torvalds skb_queue_purge(&a->packet_queue);
901da177e4SLinus Torvalds kfree(a);
911da177e4SLinus Torvalds }
921da177e4SLinus Torvalds
931da177e4SLinus Torvalds /*
941da177e4SLinus Torvalds * Send an aarp queue entry request
951da177e4SLinus Torvalds *
961da177e4SLinus Torvalds * Must run under aarp_lock.
971da177e4SLinus Torvalds */
__aarp_send_query(struct aarp_entry * a)981da177e4SLinus Torvalds static void __aarp_send_query(struct aarp_entry *a)
991da177e4SLinus Torvalds {
1001da177e4SLinus Torvalds static unsigned char aarp_eth_multicast[ETH_ALEN] =
1011da177e4SLinus Torvalds { 0x09, 0x00, 0x07, 0xFF, 0xFF, 0xFF };
1021da177e4SLinus Torvalds struct net_device *dev = a->dev;
1031da177e4SLinus Torvalds struct elapaarp *eah;
1041da177e4SLinus Torvalds int len = dev->hard_header_len + sizeof(*eah) + aarp_dl->header_length;
1051da177e4SLinus Torvalds struct sk_buff *skb = alloc_skb(len, GFP_ATOMIC);
1061da177e4SLinus Torvalds struct atalk_addr *sat = atalk_find_dev_addr(dev);
1071da177e4SLinus Torvalds
1081da177e4SLinus Torvalds if (!skb)
1091da177e4SLinus Torvalds return;
1101da177e4SLinus Torvalds
1111da177e4SLinus Torvalds if (!sat) {
1121da177e4SLinus Torvalds kfree_skb(skb);
1131da177e4SLinus Torvalds return;
1141da177e4SLinus Torvalds }
1151da177e4SLinus Torvalds
1161da177e4SLinus Torvalds /* Set up the buffer */
1171da177e4SLinus Torvalds skb_reserve(skb, dev->hard_header_len + aarp_dl->header_length);
1187e28ecc2SArnaldo Carvalho de Melo skb_reset_network_header(skb);
119badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb);
1207e28ecc2SArnaldo Carvalho de Melo skb_put(skb, sizeof(*eah));
1211da177e4SLinus Torvalds skb->protocol = htons(ETH_P_ATALK);
1221da177e4SLinus Torvalds skb->dev = dev;
1231da177e4SLinus Torvalds eah = aarp_hdr(skb);
1241da177e4SLinus Torvalds
1251da177e4SLinus Torvalds /* Set up the ARP */
1261da177e4SLinus Torvalds eah->hw_type = htons(AARP_HW_TYPE_ETHERNET);
1271da177e4SLinus Torvalds eah->pa_type = htons(ETH_P_ATALK);
1281da177e4SLinus Torvalds eah->hw_len = ETH_ALEN;
1291da177e4SLinus Torvalds eah->pa_len = AARP_PA_ALEN;
1301da177e4SLinus Torvalds eah->function = htons(AARP_REQUEST);
1311da177e4SLinus Torvalds
13290ccb6aaSJoe Perches ether_addr_copy(eah->hw_src, dev->dev_addr);
1331da177e4SLinus Torvalds
1341da177e4SLinus Torvalds eah->pa_src_zero = 0;
1351da177e4SLinus Torvalds eah->pa_src_net = sat->s_net;
1361da177e4SLinus Torvalds eah->pa_src_node = sat->s_node;
1371da177e4SLinus Torvalds
1381a73de07SJoe Perches eth_zero_addr(eah->hw_dst);
1391da177e4SLinus Torvalds
1401da177e4SLinus Torvalds eah->pa_dst_zero = 0;
1411da177e4SLinus Torvalds eah->pa_dst_net = a->target_addr.s_net;
1421da177e4SLinus Torvalds eah->pa_dst_node = a->target_addr.s_node;
1431da177e4SLinus Torvalds
1441da177e4SLinus Torvalds /* Send it */
1451da177e4SLinus Torvalds aarp_dl->request(aarp_dl, skb, aarp_eth_multicast);
1461da177e4SLinus Torvalds /* Update the sending count */
1471da177e4SLinus Torvalds a->xmit_count++;
1481da177e4SLinus Torvalds a->last_sent = jiffies;
1491da177e4SLinus Torvalds }
1501da177e4SLinus Torvalds
1511da177e4SLinus Torvalds /* This runs under aarp_lock and in softint context, so only atomic memory
1521da177e4SLinus Torvalds * allocations can be used. */
aarp_send_reply(struct net_device * dev,struct atalk_addr * us,struct atalk_addr * them,unsigned char * sha)1531da177e4SLinus Torvalds static void aarp_send_reply(struct net_device *dev, struct atalk_addr *us,
1541da177e4SLinus Torvalds struct atalk_addr *them, unsigned char *sha)
1551da177e4SLinus Torvalds {
1561da177e4SLinus Torvalds struct elapaarp *eah;
1571da177e4SLinus Torvalds int len = dev->hard_header_len + sizeof(*eah) + aarp_dl->header_length;
1581da177e4SLinus Torvalds struct sk_buff *skb = alloc_skb(len, GFP_ATOMIC);
1591da177e4SLinus Torvalds
1601da177e4SLinus Torvalds if (!skb)
1611da177e4SLinus Torvalds return;
1621da177e4SLinus Torvalds
1631da177e4SLinus Torvalds /* Set up the buffer */
1641da177e4SLinus Torvalds skb_reserve(skb, dev->hard_header_len + aarp_dl->header_length);
1657e28ecc2SArnaldo Carvalho de Melo skb_reset_network_header(skb);
166badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb);
1677e28ecc2SArnaldo Carvalho de Melo skb_put(skb, sizeof(*eah));
1681da177e4SLinus Torvalds skb->protocol = htons(ETH_P_ATALK);
1691da177e4SLinus Torvalds skb->dev = dev;
1701da177e4SLinus Torvalds eah = aarp_hdr(skb);
1711da177e4SLinus Torvalds
1721da177e4SLinus Torvalds /* Set up the ARP */
1731da177e4SLinus Torvalds eah->hw_type = htons(AARP_HW_TYPE_ETHERNET);
1741da177e4SLinus Torvalds eah->pa_type = htons(ETH_P_ATALK);
1751da177e4SLinus Torvalds eah->hw_len = ETH_ALEN;
1761da177e4SLinus Torvalds eah->pa_len = AARP_PA_ALEN;
1771da177e4SLinus Torvalds eah->function = htons(AARP_REPLY);
1781da177e4SLinus Torvalds
17990ccb6aaSJoe Perches ether_addr_copy(eah->hw_src, dev->dev_addr);
1801da177e4SLinus Torvalds
1811da177e4SLinus Torvalds eah->pa_src_zero = 0;
1821da177e4SLinus Torvalds eah->pa_src_net = us->s_net;
1831da177e4SLinus Torvalds eah->pa_src_node = us->s_node;
1841da177e4SLinus Torvalds
1851da177e4SLinus Torvalds if (!sha)
1861a73de07SJoe Perches eth_zero_addr(eah->hw_dst);
1871da177e4SLinus Torvalds else
18890ccb6aaSJoe Perches ether_addr_copy(eah->hw_dst, sha);
1891da177e4SLinus Torvalds
1901da177e4SLinus Torvalds eah->pa_dst_zero = 0;
1911da177e4SLinus Torvalds eah->pa_dst_net = them->s_net;
1921da177e4SLinus Torvalds eah->pa_dst_node = them->s_node;
1931da177e4SLinus Torvalds
1941da177e4SLinus Torvalds /* Send it */
1951da177e4SLinus Torvalds aarp_dl->request(aarp_dl, skb, sha);
1961da177e4SLinus Torvalds }
1971da177e4SLinus Torvalds
1981da177e4SLinus Torvalds /*
1991da177e4SLinus Torvalds * Send probe frames. Called from aarp_probe_network and
2001da177e4SLinus Torvalds * aarp_proxy_probe_network.
2011da177e4SLinus Torvalds */
2021da177e4SLinus Torvalds
aarp_send_probe(struct net_device * dev,struct atalk_addr * us)2031da177e4SLinus Torvalds static void aarp_send_probe(struct net_device *dev, struct atalk_addr *us)
2041da177e4SLinus Torvalds {
2051da177e4SLinus Torvalds struct elapaarp *eah;
2061da177e4SLinus Torvalds int len = dev->hard_header_len + sizeof(*eah) + aarp_dl->header_length;
2071da177e4SLinus Torvalds struct sk_buff *skb = alloc_skb(len, GFP_ATOMIC);
2081da177e4SLinus Torvalds static unsigned char aarp_eth_multicast[ETH_ALEN] =
2091da177e4SLinus Torvalds { 0x09, 0x00, 0x07, 0xFF, 0xFF, 0xFF };
2101da177e4SLinus Torvalds
2111da177e4SLinus Torvalds if (!skb)
2121da177e4SLinus Torvalds return;
2131da177e4SLinus Torvalds
2141da177e4SLinus Torvalds /* Set up the buffer */
2151da177e4SLinus Torvalds skb_reserve(skb, dev->hard_header_len + aarp_dl->header_length);
2167e28ecc2SArnaldo Carvalho de Melo skb_reset_network_header(skb);
217badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb);
2187e28ecc2SArnaldo Carvalho de Melo skb_put(skb, sizeof(*eah));
2191da177e4SLinus Torvalds skb->protocol = htons(ETH_P_ATALK);
2201da177e4SLinus Torvalds skb->dev = dev;
2211da177e4SLinus Torvalds eah = aarp_hdr(skb);
2221da177e4SLinus Torvalds
2231da177e4SLinus Torvalds /* Set up the ARP */
2241da177e4SLinus Torvalds eah->hw_type = htons(AARP_HW_TYPE_ETHERNET);
2251da177e4SLinus Torvalds eah->pa_type = htons(ETH_P_ATALK);
2261da177e4SLinus Torvalds eah->hw_len = ETH_ALEN;
2271da177e4SLinus Torvalds eah->pa_len = AARP_PA_ALEN;
2281da177e4SLinus Torvalds eah->function = htons(AARP_PROBE);
2291da177e4SLinus Torvalds
23090ccb6aaSJoe Perches ether_addr_copy(eah->hw_src, dev->dev_addr);
2311da177e4SLinus Torvalds
2321da177e4SLinus Torvalds eah->pa_src_zero = 0;
2331da177e4SLinus Torvalds eah->pa_src_net = us->s_net;
2341da177e4SLinus Torvalds eah->pa_src_node = us->s_node;
2351da177e4SLinus Torvalds
2361a73de07SJoe Perches eth_zero_addr(eah->hw_dst);
2371da177e4SLinus Torvalds
2381da177e4SLinus Torvalds eah->pa_dst_zero = 0;
2391da177e4SLinus Torvalds eah->pa_dst_net = us->s_net;
2401da177e4SLinus Torvalds eah->pa_dst_node = us->s_node;
2411da177e4SLinus Torvalds
2421da177e4SLinus Torvalds /* Send it */
2431da177e4SLinus Torvalds aarp_dl->request(aarp_dl, skb, aarp_eth_multicast);
2441da177e4SLinus Torvalds }
2451da177e4SLinus Torvalds
2461da177e4SLinus Torvalds /*
2471da177e4SLinus Torvalds * Handle an aarp timer expire
2481da177e4SLinus Torvalds *
2491da177e4SLinus Torvalds * Must run under the aarp_lock.
2501da177e4SLinus Torvalds */
2511da177e4SLinus Torvalds
__aarp_expire_timer(struct aarp_entry ** n)2521da177e4SLinus Torvalds static void __aarp_expire_timer(struct aarp_entry **n)
2531da177e4SLinus Torvalds {
2541da177e4SLinus Torvalds struct aarp_entry *t;
2551da177e4SLinus Torvalds
2561da177e4SLinus Torvalds while (*n)
2571da177e4SLinus Torvalds /* Expired ? */
2581da177e4SLinus Torvalds if (time_after(jiffies, (*n)->expires_at)) {
2591da177e4SLinus Torvalds t = *n;
2601da177e4SLinus Torvalds *n = (*n)->next;
2611da177e4SLinus Torvalds __aarp_expire(t);
2621da177e4SLinus Torvalds } else
2631da177e4SLinus Torvalds n = &((*n)->next);
2641da177e4SLinus Torvalds }
2651da177e4SLinus Torvalds
2661da177e4SLinus Torvalds /*
2671da177e4SLinus Torvalds * Kick all pending requests 5 times a second.
2681da177e4SLinus Torvalds *
2691da177e4SLinus Torvalds * Must run under the aarp_lock.
2701da177e4SLinus Torvalds */
__aarp_kick(struct aarp_entry ** n)2711da177e4SLinus Torvalds static void __aarp_kick(struct aarp_entry **n)
2721da177e4SLinus Torvalds {
2731da177e4SLinus Torvalds struct aarp_entry *t;
2741da177e4SLinus Torvalds
2751da177e4SLinus Torvalds while (*n)
2761da177e4SLinus Torvalds /* Expired: if this will be the 11th tx, we delete instead. */
2771da177e4SLinus Torvalds if ((*n)->xmit_count >= sysctl_aarp_retransmit_limit) {
2781da177e4SLinus Torvalds t = *n;
2791da177e4SLinus Torvalds *n = (*n)->next;
2801da177e4SLinus Torvalds __aarp_expire(t);
2811da177e4SLinus Torvalds } else {
2821da177e4SLinus Torvalds __aarp_send_query(*n);
2831da177e4SLinus Torvalds n = &((*n)->next);
2841da177e4SLinus Torvalds }
2851da177e4SLinus Torvalds }
2861da177e4SLinus Torvalds
2871da177e4SLinus Torvalds /*
2881da177e4SLinus Torvalds * A device has gone down. Take all entries referring to the device
2891da177e4SLinus Torvalds * and remove them.
2901da177e4SLinus Torvalds *
2911da177e4SLinus Torvalds * Must run under the aarp_lock.
2921da177e4SLinus Torvalds */
__aarp_expire_device(struct aarp_entry ** n,struct net_device * dev)2931da177e4SLinus Torvalds static void __aarp_expire_device(struct aarp_entry **n, struct net_device *dev)
2941da177e4SLinus Torvalds {
2951da177e4SLinus Torvalds struct aarp_entry *t;
2961da177e4SLinus Torvalds
2971da177e4SLinus Torvalds while (*n)
2981da177e4SLinus Torvalds if ((*n)->dev == dev) {
2991da177e4SLinus Torvalds t = *n;
3001da177e4SLinus Torvalds *n = (*n)->next;
3011da177e4SLinus Torvalds __aarp_expire(t);
3021da177e4SLinus Torvalds } else
3031da177e4SLinus Torvalds n = &((*n)->next);
3041da177e4SLinus Torvalds }
3051da177e4SLinus Torvalds
3061da177e4SLinus Torvalds /* Handle the timer event */
aarp_expire_timeout(struct timer_list * unused)307e99e88a9SKees Cook static void aarp_expire_timeout(struct timer_list *unused)
3081da177e4SLinus Torvalds {
3091da177e4SLinus Torvalds int ct;
3101da177e4SLinus Torvalds
3111da177e4SLinus Torvalds write_lock_bh(&aarp_lock);
3121da177e4SLinus Torvalds
3131da177e4SLinus Torvalds for (ct = 0; ct < AARP_HASH_SIZE; ct++) {
3141da177e4SLinus Torvalds __aarp_expire_timer(&resolved[ct]);
3151da177e4SLinus Torvalds __aarp_kick(&unresolved[ct]);
3161da177e4SLinus Torvalds __aarp_expire_timer(&unresolved[ct]);
3171da177e4SLinus Torvalds __aarp_expire_timer(&proxies[ct]);
3181da177e4SLinus Torvalds }
3191da177e4SLinus Torvalds
3201da177e4SLinus Torvalds write_unlock_bh(&aarp_lock);
3211da177e4SLinus Torvalds mod_timer(&aarp_timer, jiffies +
3221da177e4SLinus Torvalds (unresolved_count ? sysctl_aarp_tick_time :
3231da177e4SLinus Torvalds sysctl_aarp_expiry_time));
3241da177e4SLinus Torvalds }
3251da177e4SLinus Torvalds
3261da177e4SLinus Torvalds /* Network device notifier chain handler. */
aarp_device_event(struct notifier_block * this,unsigned long event,void * ptr)3271da177e4SLinus Torvalds static int aarp_device_event(struct notifier_block *this, unsigned long event,
3281da177e4SLinus Torvalds void *ptr)
3291da177e4SLinus Torvalds {
330351638e7SJiri Pirko struct net_device *dev = netdev_notifier_info_to_dev(ptr);
3311da177e4SLinus Torvalds int ct;
3321da177e4SLinus Torvalds
333721499e8SYOSHIFUJI Hideaki if (!net_eq(dev_net(dev), &init_net))
334e9dc8653SEric W. Biederman return NOTIFY_DONE;
335e9dc8653SEric W. Biederman
3361da177e4SLinus Torvalds if (event == NETDEV_DOWN) {
3371da177e4SLinus Torvalds write_lock_bh(&aarp_lock);
3381da177e4SLinus Torvalds
3391da177e4SLinus Torvalds for (ct = 0; ct < AARP_HASH_SIZE; ct++) {
340890d52d3SEric W. Biederman __aarp_expire_device(&resolved[ct], dev);
341890d52d3SEric W. Biederman __aarp_expire_device(&unresolved[ct], dev);
342890d52d3SEric W. Biederman __aarp_expire_device(&proxies[ct], dev);
3431da177e4SLinus Torvalds }
3441da177e4SLinus Torvalds
3451da177e4SLinus Torvalds write_unlock_bh(&aarp_lock);
3461da177e4SLinus Torvalds }
3471da177e4SLinus Torvalds return NOTIFY_DONE;
3481da177e4SLinus Torvalds }
3491da177e4SLinus Torvalds
3501da177e4SLinus Torvalds /* Expire all entries in a hash chain */
__aarp_expire_all(struct aarp_entry ** n)3511da177e4SLinus Torvalds static void __aarp_expire_all(struct aarp_entry **n)
3521da177e4SLinus Torvalds {
3531da177e4SLinus Torvalds struct aarp_entry *t;
3541da177e4SLinus Torvalds
3551da177e4SLinus Torvalds while (*n) {
3561da177e4SLinus Torvalds t = *n;
3571da177e4SLinus Torvalds *n = (*n)->next;
3581da177e4SLinus Torvalds __aarp_expire(t);
3591da177e4SLinus Torvalds }
3601da177e4SLinus Torvalds }
3611da177e4SLinus Torvalds
3621da177e4SLinus Torvalds /* Cleanup all hash chains -- module unloading */
aarp_purge(void)3631da177e4SLinus Torvalds static void aarp_purge(void)
3641da177e4SLinus Torvalds {
3651da177e4SLinus Torvalds int ct;
3661da177e4SLinus Torvalds
3671da177e4SLinus Torvalds write_lock_bh(&aarp_lock);
3681da177e4SLinus Torvalds for (ct = 0; ct < AARP_HASH_SIZE; ct++) {
3691da177e4SLinus Torvalds __aarp_expire_all(&resolved[ct]);
3701da177e4SLinus Torvalds __aarp_expire_all(&unresolved[ct]);
3711da177e4SLinus Torvalds __aarp_expire_all(&proxies[ct]);
3721da177e4SLinus Torvalds }
3731da177e4SLinus Torvalds write_unlock_bh(&aarp_lock);
3741da177e4SLinus Torvalds }
3751da177e4SLinus Torvalds
3761da177e4SLinus Torvalds /*
3771da177e4SLinus Torvalds * Create a new aarp entry. This must use GFP_ATOMIC because it
3781da177e4SLinus Torvalds * runs while holding spinlocks.
3791da177e4SLinus Torvalds */
aarp_alloc(void)3801da177e4SLinus Torvalds static struct aarp_entry *aarp_alloc(void)
3811da177e4SLinus Torvalds {
3821da177e4SLinus Torvalds struct aarp_entry *a = kmalloc(sizeof(*a), GFP_ATOMIC);
3831da177e4SLinus Torvalds
3841da177e4SLinus Torvalds if (a)
3851da177e4SLinus Torvalds skb_queue_head_init(&a->packet_queue);
3861da177e4SLinus Torvalds return a;
3871da177e4SLinus Torvalds }
3881da177e4SLinus Torvalds
3891da177e4SLinus Torvalds /*
3901da177e4SLinus Torvalds * Find an entry. We might return an expired but not yet purged entry. We
3911da177e4SLinus Torvalds * don't care as it will do no harm.
3921da177e4SLinus Torvalds *
3931da177e4SLinus Torvalds * This must run under the aarp_lock.
3941da177e4SLinus Torvalds */
__aarp_find_entry(struct aarp_entry * list,struct net_device * dev,struct atalk_addr * sat)3951da177e4SLinus Torvalds static struct aarp_entry *__aarp_find_entry(struct aarp_entry *list,
3961da177e4SLinus Torvalds struct net_device *dev,
3971da177e4SLinus Torvalds struct atalk_addr *sat)
3981da177e4SLinus Torvalds {
3991da177e4SLinus Torvalds while (list) {
4001da177e4SLinus Torvalds if (list->target_addr.s_net == sat->s_net &&
4011da177e4SLinus Torvalds list->target_addr.s_node == sat->s_node &&
4021da177e4SLinus Torvalds list->dev == dev)
4031da177e4SLinus Torvalds break;
4041da177e4SLinus Torvalds list = list->next;
4051da177e4SLinus Torvalds }
4061da177e4SLinus Torvalds
4071da177e4SLinus Torvalds return list;
4081da177e4SLinus Torvalds }
4091da177e4SLinus Torvalds
4101da177e4SLinus Torvalds /* Called from the DDP code, and thus must be exported. */
aarp_proxy_remove(struct net_device * dev,struct atalk_addr * sa)4111da177e4SLinus Torvalds void aarp_proxy_remove(struct net_device *dev, struct atalk_addr *sa)
4121da177e4SLinus Torvalds {
4131da177e4SLinus Torvalds int hash = sa->s_node % (AARP_HASH_SIZE - 1);
4141da177e4SLinus Torvalds struct aarp_entry *a;
4151da177e4SLinus Torvalds
4161da177e4SLinus Torvalds write_lock_bh(&aarp_lock);
4171da177e4SLinus Torvalds
4181da177e4SLinus Torvalds a = __aarp_find_entry(proxies[hash], dev, sa);
4191da177e4SLinus Torvalds if (a)
4201da177e4SLinus Torvalds a->expires_at = jiffies - 1;
4211da177e4SLinus Torvalds
4221da177e4SLinus Torvalds write_unlock_bh(&aarp_lock);
4231da177e4SLinus Torvalds }
4241da177e4SLinus Torvalds
4251da177e4SLinus Torvalds /* This must run under aarp_lock. */
__aarp_proxy_find(struct net_device * dev,struct atalk_addr * sa)4261da177e4SLinus Torvalds static struct atalk_addr *__aarp_proxy_find(struct net_device *dev,
4271da177e4SLinus Torvalds struct atalk_addr *sa)
4281da177e4SLinus Torvalds {
4291da177e4SLinus Torvalds int hash = sa->s_node % (AARP_HASH_SIZE - 1);
4301da177e4SLinus Torvalds struct aarp_entry *a = __aarp_find_entry(proxies[hash], dev, sa);
4311da177e4SLinus Torvalds
4321da177e4SLinus Torvalds return a ? sa : NULL;
4331da177e4SLinus Torvalds }
4341da177e4SLinus Torvalds
4351da177e4SLinus Torvalds /*
4361da177e4SLinus Torvalds * Probe a Phase 1 device or a device that requires its Net:Node to
4371da177e4SLinus Torvalds * be set via an ioctl.
4381da177e4SLinus Torvalds */
aarp_send_probe_phase1(struct atalk_iface * iface)4391da177e4SLinus Torvalds static void aarp_send_probe_phase1(struct atalk_iface *iface)
4401da177e4SLinus Torvalds {
4411da177e4SLinus Torvalds struct ifreq atreq;
4421da177e4SLinus Torvalds struct sockaddr_at *sa = (struct sockaddr_at *)&atreq.ifr_addr;
44303b35ccbSStephen Hemminger const struct net_device_ops *ops = iface->dev->netdev_ops;
4441da177e4SLinus Torvalds
4451da177e4SLinus Torvalds sa->sat_addr.s_node = iface->address.s_node;
4461da177e4SLinus Torvalds sa->sat_addr.s_net = ntohs(iface->address.s_net);
4471da177e4SLinus Torvalds
4481da177e4SLinus Torvalds /* We pass the Net:Node to the drivers/cards by a Device ioctl. */
44903b35ccbSStephen Hemminger if (!(ops->ndo_do_ioctl(iface->dev, &atreq, SIOCSIFADDR))) {
45003b35ccbSStephen Hemminger ops->ndo_do_ioctl(iface->dev, &atreq, SIOCGIFADDR);
4511da177e4SLinus Torvalds if (iface->address.s_net != htons(sa->sat_addr.s_net) ||
4521da177e4SLinus Torvalds iface->address.s_node != sa->sat_addr.s_node)
4531da177e4SLinus Torvalds iface->status |= ATIF_PROBE_FAIL;
4541da177e4SLinus Torvalds
4551da177e4SLinus Torvalds iface->address.s_net = htons(sa->sat_addr.s_net);
4561da177e4SLinus Torvalds iface->address.s_node = sa->sat_addr.s_node;
4571da177e4SLinus Torvalds }
4581da177e4SLinus Torvalds }
4591da177e4SLinus Torvalds
4601da177e4SLinus Torvalds
aarp_probe_network(struct atalk_iface * atif)4611da177e4SLinus Torvalds void aarp_probe_network(struct atalk_iface *atif)
4621da177e4SLinus Torvalds {
4631da177e4SLinus Torvalds if (atif->dev->type == ARPHRD_LOCALTLK ||
4641da177e4SLinus Torvalds atif->dev->type == ARPHRD_PPP)
4651da177e4SLinus Torvalds aarp_send_probe_phase1(atif);
4661da177e4SLinus Torvalds else {
4671da177e4SLinus Torvalds unsigned int count;
4681da177e4SLinus Torvalds
4691da177e4SLinus Torvalds for (count = 0; count < AARP_RETRANSMIT_LIMIT; count++) {
4701da177e4SLinus Torvalds aarp_send_probe(atif->dev, &atif->address);
4711da177e4SLinus Torvalds
4721da177e4SLinus Torvalds /* Defer 1/10th */
473285b3afeSNishanth Aravamudan msleep(100);
4741da177e4SLinus Torvalds
4751da177e4SLinus Torvalds if (atif->status & ATIF_PROBE_FAIL)
4761da177e4SLinus Torvalds break;
4771da177e4SLinus Torvalds }
4781da177e4SLinus Torvalds }
4791da177e4SLinus Torvalds }
4801da177e4SLinus Torvalds
aarp_proxy_probe_network(struct atalk_iface * atif,struct atalk_addr * sa)4811da177e4SLinus Torvalds int aarp_proxy_probe_network(struct atalk_iface *atif, struct atalk_addr *sa)
4821da177e4SLinus Torvalds {
4831da177e4SLinus Torvalds int hash, retval = -EPROTONOSUPPORT;
4841da177e4SLinus Torvalds struct aarp_entry *entry;
4851da177e4SLinus Torvalds unsigned int count;
4861da177e4SLinus Torvalds
4871da177e4SLinus Torvalds /*
4881da177e4SLinus Torvalds * we don't currently support LocalTalk or PPP for proxy AARP;
4891da177e4SLinus Torvalds * if someone wants to try and add it, have fun
4901da177e4SLinus Torvalds */
4911da177e4SLinus Torvalds if (atif->dev->type == ARPHRD_LOCALTLK ||
4921da177e4SLinus Torvalds atif->dev->type == ARPHRD_PPP)
4931da177e4SLinus Torvalds goto out;
4941da177e4SLinus Torvalds
4951da177e4SLinus Torvalds /*
4961da177e4SLinus Torvalds * create a new AARP entry with the flags set to be published --
4971da177e4SLinus Torvalds * we need this one to hang around even if it's in use
4981da177e4SLinus Torvalds */
4991da177e4SLinus Torvalds entry = aarp_alloc();
5001da177e4SLinus Torvalds retval = -ENOMEM;
5011da177e4SLinus Torvalds if (!entry)
5021da177e4SLinus Torvalds goto out;
5031da177e4SLinus Torvalds
5041da177e4SLinus Torvalds entry->expires_at = -1;
5051da177e4SLinus Torvalds entry->status = ATIF_PROBE;
5061da177e4SLinus Torvalds entry->target_addr.s_node = sa->s_node;
5071da177e4SLinus Torvalds entry->target_addr.s_net = sa->s_net;
5081da177e4SLinus Torvalds entry->dev = atif->dev;
5091da177e4SLinus Torvalds
5101da177e4SLinus Torvalds write_lock_bh(&aarp_lock);
5111da177e4SLinus Torvalds
5121da177e4SLinus Torvalds hash = sa->s_node % (AARP_HASH_SIZE - 1);
5131da177e4SLinus Torvalds entry->next = proxies[hash];
5141da177e4SLinus Torvalds proxies[hash] = entry;
5151da177e4SLinus Torvalds
5161da177e4SLinus Torvalds for (count = 0; count < AARP_RETRANSMIT_LIMIT; count++) {
5171da177e4SLinus Torvalds aarp_send_probe(atif->dev, sa);
5181da177e4SLinus Torvalds
5191da177e4SLinus Torvalds /* Defer 1/10th */
5201da177e4SLinus Torvalds write_unlock_bh(&aarp_lock);
521285b3afeSNishanth Aravamudan msleep(100);
5221da177e4SLinus Torvalds write_lock_bh(&aarp_lock);
5231da177e4SLinus Torvalds
5241da177e4SLinus Torvalds if (entry->status & ATIF_PROBE_FAIL)
5251da177e4SLinus Torvalds break;
5261da177e4SLinus Torvalds }
5271da177e4SLinus Torvalds
5281da177e4SLinus Torvalds if (entry->status & ATIF_PROBE_FAIL) {
5291da177e4SLinus Torvalds entry->expires_at = jiffies - 1; /* free the entry */
5301da177e4SLinus Torvalds retval = -EADDRINUSE; /* return network full */
5311da177e4SLinus Torvalds } else { /* clear the probing flag */
5321da177e4SLinus Torvalds entry->status &= ~ATIF_PROBE;
5331da177e4SLinus Torvalds retval = 1;
5341da177e4SLinus Torvalds }
5351da177e4SLinus Torvalds
5361da177e4SLinus Torvalds write_unlock_bh(&aarp_lock);
5371da177e4SLinus Torvalds out:
5381da177e4SLinus Torvalds return retval;
5391da177e4SLinus Torvalds }
5401da177e4SLinus Torvalds
5411da177e4SLinus Torvalds /* Send a DDP frame */
aarp_send_ddp(struct net_device * dev,struct sk_buff * skb,struct atalk_addr * sa,void * hwaddr)5421da177e4SLinus Torvalds int aarp_send_ddp(struct net_device *dev, struct sk_buff *skb,
5431da177e4SLinus Torvalds struct atalk_addr *sa, void *hwaddr)
5441da177e4SLinus Torvalds {
5451da177e4SLinus Torvalds static char ddp_eth_multicast[ETH_ALEN] =
5461da177e4SLinus Torvalds { 0x09, 0x00, 0x07, 0xFF, 0xFF, 0xFF };
5471da177e4SLinus Torvalds int hash;
5481da177e4SLinus Torvalds struct aarp_entry *a;
5491da177e4SLinus Torvalds
550c1d2bbe1SArnaldo Carvalho de Melo skb_reset_network_header(skb);
5511da177e4SLinus Torvalds
5521da177e4SLinus Torvalds /* Check for LocalTalk first */
5531da177e4SLinus Torvalds if (dev->type == ARPHRD_LOCALTLK) {
5541da177e4SLinus Torvalds struct atalk_addr *at = atalk_find_dev_addr(dev);
5551da177e4SLinus Torvalds struct ddpehdr *ddp = (struct ddpehdr *)skb->data;
5561da177e4SLinus Torvalds int ft = 2;
5571da177e4SLinus Torvalds
5581da177e4SLinus Torvalds /*
5591da177e4SLinus Torvalds * Compressible ?
5601da177e4SLinus Torvalds *
5611da177e4SLinus Torvalds * IFF: src_net == dest_net == device_net
5621da177e4SLinus Torvalds * (zero matches anything)
5631da177e4SLinus Torvalds */
5641da177e4SLinus Torvalds
5651da177e4SLinus Torvalds if ((!ddp->deh_snet || at->s_net == ddp->deh_snet) &&
5661da177e4SLinus Torvalds (!ddp->deh_dnet || at->s_net == ddp->deh_dnet)) {
5671da177e4SLinus Torvalds skb_pull(skb, sizeof(*ddp) - 4);
5681da177e4SLinus Torvalds
5691da177e4SLinus Torvalds /*
5701da177e4SLinus Torvalds * The upper two remaining bytes are the port
5711da177e4SLinus Torvalds * numbers we just happen to need. Now put the
5721da177e4SLinus Torvalds * length in the lower two.
5731da177e4SLinus Torvalds */
574f6e276eeSAlexey Dobriyan *((__be16 *)skb->data) = htons(skb->len);
5751da177e4SLinus Torvalds ft = 1;
5761da177e4SLinus Torvalds }
5771da177e4SLinus Torvalds /*
5781da177e4SLinus Torvalds * Nice and easy. No AARP type protocols occur here so we can
5791da177e4SLinus Torvalds * just shovel it out with a 3 byte LLAP header
5801da177e4SLinus Torvalds */
5811da177e4SLinus Torvalds
5821da177e4SLinus Torvalds skb_push(skb, 3);
5831da177e4SLinus Torvalds skb->data[0] = sa->s_node;
5841da177e4SLinus Torvalds skb->data[1] = at->s_node;
5851da177e4SLinus Torvalds skb->data[2] = ft;
5861da177e4SLinus Torvalds skb->dev = dev;
5871da177e4SLinus Torvalds goto sendit;
5881da177e4SLinus Torvalds }
5891da177e4SLinus Torvalds
5901da177e4SLinus Torvalds /* On a PPP link we neither compress nor aarp. */
5911da177e4SLinus Torvalds if (dev->type == ARPHRD_PPP) {
5921da177e4SLinus Torvalds skb->protocol = htons(ETH_P_PPPTALK);
5931da177e4SLinus Torvalds skb->dev = dev;
5941da177e4SLinus Torvalds goto sendit;
5951da177e4SLinus Torvalds }
5961da177e4SLinus Torvalds
5971da177e4SLinus Torvalds /* Non ELAP we cannot do. */
5981da177e4SLinus Torvalds if (dev->type != ARPHRD_ETHER)
599ffcfb8dbSArnaldo Carvalho de Melo goto free_it;
6001da177e4SLinus Torvalds
6011da177e4SLinus Torvalds skb->dev = dev;
6021da177e4SLinus Torvalds skb->protocol = htons(ETH_P_ATALK);
6031da177e4SLinus Torvalds hash = sa->s_node % (AARP_HASH_SIZE - 1);
6041da177e4SLinus Torvalds
6051da177e4SLinus Torvalds /* Do we have a resolved entry? */
6061da177e4SLinus Torvalds if (sa->s_node == ATADDR_BCAST) {
6071da177e4SLinus Torvalds /* Send it */
6081da177e4SLinus Torvalds ddp_dl->request(ddp_dl, skb, ddp_eth_multicast);
6091da177e4SLinus Torvalds goto sent;
6101da177e4SLinus Torvalds }
6111da177e4SLinus Torvalds
6121da177e4SLinus Torvalds write_lock_bh(&aarp_lock);
6131da177e4SLinus Torvalds a = __aarp_find_entry(resolved[hash], dev, sa);
6141da177e4SLinus Torvalds
6151da177e4SLinus Torvalds if (a) { /* Return 1 and fill in the address */
6161da177e4SLinus Torvalds a->expires_at = jiffies + (sysctl_aarp_expiry_time * 10);
6171da177e4SLinus Torvalds ddp_dl->request(ddp_dl, skb, a->hwaddr);
6181da177e4SLinus Torvalds write_unlock_bh(&aarp_lock);
6191da177e4SLinus Torvalds goto sent;
6201da177e4SLinus Torvalds }
6211da177e4SLinus Torvalds
6221da177e4SLinus Torvalds /* Do we have an unresolved entry: This is the less common path */
6231da177e4SLinus Torvalds a = __aarp_find_entry(unresolved[hash], dev, sa);
6241da177e4SLinus Torvalds if (a) { /* Queue onto the unresolved queue */
6251da177e4SLinus Torvalds skb_queue_tail(&a->packet_queue, skb);
6261da177e4SLinus Torvalds goto out_unlock;
6271da177e4SLinus Torvalds }
6281da177e4SLinus Torvalds
6291da177e4SLinus Torvalds /* Allocate a new entry */
6301da177e4SLinus Torvalds a = aarp_alloc();
6311da177e4SLinus Torvalds if (!a) {
6321da177e4SLinus Torvalds /* Whoops slipped... good job it's an unreliable protocol 8) */
6331da177e4SLinus Torvalds write_unlock_bh(&aarp_lock);
634ffcfb8dbSArnaldo Carvalho de Melo goto free_it;
6351da177e4SLinus Torvalds }
6361da177e4SLinus Torvalds
6371da177e4SLinus Torvalds /* Set up the queue */
6381da177e4SLinus Torvalds skb_queue_tail(&a->packet_queue, skb);
6391da177e4SLinus Torvalds a->expires_at = jiffies + sysctl_aarp_resolve_time;
6401da177e4SLinus Torvalds a->dev = dev;
6411da177e4SLinus Torvalds a->next = unresolved[hash];
6421da177e4SLinus Torvalds a->target_addr = *sa;
6431da177e4SLinus Torvalds a->xmit_count = 0;
6441da177e4SLinus Torvalds unresolved[hash] = a;
6451da177e4SLinus Torvalds unresolved_count++;
6461da177e4SLinus Torvalds
6471da177e4SLinus Torvalds /* Send an initial request for the address */
6481da177e4SLinus Torvalds __aarp_send_query(a);
6491da177e4SLinus Torvalds
6501da177e4SLinus Torvalds /*
6511da177e4SLinus Torvalds * Switch to fast timer if needed (That is if this is the first
6521da177e4SLinus Torvalds * unresolved entry to get added)
6531da177e4SLinus Torvalds */
6541da177e4SLinus Torvalds
6551da177e4SLinus Torvalds if (unresolved_count == 1)
6561da177e4SLinus Torvalds mod_timer(&aarp_timer, jiffies + sysctl_aarp_tick_time);
6571da177e4SLinus Torvalds
6581da177e4SLinus Torvalds /* Now finally, it is safe to drop the lock. */
6591da177e4SLinus Torvalds out_unlock:
6601da177e4SLinus Torvalds write_unlock_bh(&aarp_lock);
6611da177e4SLinus Torvalds
6621da177e4SLinus Torvalds /* Tell the ddp layer we have taken over for this frame. */
663ffcfb8dbSArnaldo Carvalho de Melo goto sent;
6641da177e4SLinus Torvalds
6651da177e4SLinus Torvalds sendit:
6661da177e4SLinus Torvalds if (skb->sk)
667*10bbf165SEric Dumazet skb->priority = READ_ONCE(skb->sk->sk_priority);
668ffcfb8dbSArnaldo Carvalho de Melo if (dev_queue_xmit(skb))
669ffcfb8dbSArnaldo Carvalho de Melo goto drop;
6701da177e4SLinus Torvalds sent:
671ffcfb8dbSArnaldo Carvalho de Melo return NET_XMIT_SUCCESS;
672ffcfb8dbSArnaldo Carvalho de Melo free_it:
673ffcfb8dbSArnaldo Carvalho de Melo kfree_skb(skb);
674ffcfb8dbSArnaldo Carvalho de Melo drop:
675ffcfb8dbSArnaldo Carvalho de Melo return NET_XMIT_DROP;
6761da177e4SLinus Torvalds }
677ffcfb8dbSArnaldo Carvalho de Melo EXPORT_SYMBOL(aarp_send_ddp);
6781da177e4SLinus Torvalds
6791da177e4SLinus Torvalds /*
6801da177e4SLinus Torvalds * An entry in the aarp unresolved queue has become resolved. Send
6811da177e4SLinus Torvalds * all the frames queued under it.
6821da177e4SLinus Torvalds *
6831da177e4SLinus Torvalds * Must run under aarp_lock.
6841da177e4SLinus Torvalds */
__aarp_resolved(struct aarp_entry ** list,struct aarp_entry * a,int hash)6851da177e4SLinus Torvalds static void __aarp_resolved(struct aarp_entry **list, struct aarp_entry *a,
6861da177e4SLinus Torvalds int hash)
6871da177e4SLinus Torvalds {
6881da177e4SLinus Torvalds struct sk_buff *skb;
6891da177e4SLinus Torvalds
6901da177e4SLinus Torvalds while (*list)
6911da177e4SLinus Torvalds if (*list == a) {
6921da177e4SLinus Torvalds unresolved_count--;
6931da177e4SLinus Torvalds *list = a->next;
6941da177e4SLinus Torvalds
6951da177e4SLinus Torvalds /* Move into the resolved list */
6961da177e4SLinus Torvalds a->next = resolved[hash];
6971da177e4SLinus Torvalds resolved[hash] = a;
6981da177e4SLinus Torvalds
6991da177e4SLinus Torvalds /* Kick frames off */
7001da177e4SLinus Torvalds while ((skb = skb_dequeue(&a->packet_queue)) != NULL) {
7011da177e4SLinus Torvalds a->expires_at = jiffies +
7021da177e4SLinus Torvalds sysctl_aarp_expiry_time * 10;
7031da177e4SLinus Torvalds ddp_dl->request(ddp_dl, skb, a->hwaddr);
7041da177e4SLinus Torvalds }
7051da177e4SLinus Torvalds } else
7061da177e4SLinus Torvalds list = &((*list)->next);
7071da177e4SLinus Torvalds }
7081da177e4SLinus Torvalds
7091da177e4SLinus Torvalds /*
7101da177e4SLinus Torvalds * This is called by the SNAP driver whenever we see an AARP SNAP
7111da177e4SLinus Torvalds * frame. We currently only support Ethernet.
7121da177e4SLinus Torvalds */
aarp_rcv(struct sk_buff * skb,struct net_device * dev,struct packet_type * pt,struct net_device * orig_dev)7131da177e4SLinus Torvalds static int aarp_rcv(struct sk_buff *skb, struct net_device *dev,
714f2ccd8faSDavid S. Miller struct packet_type *pt, struct net_device *orig_dev)
7151da177e4SLinus Torvalds {
7161da177e4SLinus Torvalds struct elapaarp *ea = aarp_hdr(skb);
7171da177e4SLinus Torvalds int hash, ret = 0;
7181da177e4SLinus Torvalds __u16 function;
7191da177e4SLinus Torvalds struct aarp_entry *a;
7201da177e4SLinus Torvalds struct atalk_addr sa, *ma, da;
7211da177e4SLinus Torvalds struct atalk_iface *ifa;
7221da177e4SLinus Torvalds
723721499e8SYOSHIFUJI Hideaki if (!net_eq(dev_net(dev), &init_net))
724e730c155SEric W. Biederman goto out0;
725e730c155SEric W. Biederman
7261da177e4SLinus Torvalds /* We only do Ethernet SNAP AARP. */
7271da177e4SLinus Torvalds if (dev->type != ARPHRD_ETHER)
7281da177e4SLinus Torvalds goto out0;
7291da177e4SLinus Torvalds
7301da177e4SLinus Torvalds /* Frame size ok? */
7311da177e4SLinus Torvalds if (!skb_pull(skb, sizeof(*ea)))
7321da177e4SLinus Torvalds goto out0;
7331da177e4SLinus Torvalds
7341da177e4SLinus Torvalds function = ntohs(ea->function);
7351da177e4SLinus Torvalds
7361da177e4SLinus Torvalds /* Sanity check fields. */
7371da177e4SLinus Torvalds if (function < AARP_REQUEST || function > AARP_PROBE ||
7381da177e4SLinus Torvalds ea->hw_len != ETH_ALEN || ea->pa_len != AARP_PA_ALEN ||
7391da177e4SLinus Torvalds ea->pa_src_zero || ea->pa_dst_zero)
7401da177e4SLinus Torvalds goto out0;
7411da177e4SLinus Torvalds
7421da177e4SLinus Torvalds /* Looks good. */
7431da177e4SLinus Torvalds hash = ea->pa_src_node % (AARP_HASH_SIZE - 1);
7441da177e4SLinus Torvalds
7451da177e4SLinus Torvalds /* Build an address. */
7461da177e4SLinus Torvalds sa.s_node = ea->pa_src_node;
7471da177e4SLinus Torvalds sa.s_net = ea->pa_src_net;
7481da177e4SLinus Torvalds
7491da177e4SLinus Torvalds /* Process the packet. Check for replies of me. */
7501da177e4SLinus Torvalds ifa = atalk_find_dev(dev);
7511da177e4SLinus Torvalds if (!ifa)
7521da177e4SLinus Torvalds goto out1;
7531da177e4SLinus Torvalds
7541da177e4SLinus Torvalds if (ifa->status & ATIF_PROBE &&
7551da177e4SLinus Torvalds ifa->address.s_node == ea->pa_dst_node &&
7561da177e4SLinus Torvalds ifa->address.s_net == ea->pa_dst_net) {
7571da177e4SLinus Torvalds ifa->status |= ATIF_PROBE_FAIL; /* Fail the probe (in use) */
7581da177e4SLinus Torvalds goto out1;
7591da177e4SLinus Torvalds }
7601da177e4SLinus Torvalds
7611da177e4SLinus Torvalds /* Check for replies of proxy AARP entries */
7621da177e4SLinus Torvalds da.s_node = ea->pa_dst_node;
7631da177e4SLinus Torvalds da.s_net = ea->pa_dst_net;
7641da177e4SLinus Torvalds
7651da177e4SLinus Torvalds write_lock_bh(&aarp_lock);
7661da177e4SLinus Torvalds a = __aarp_find_entry(proxies[hash], dev, &da);
7671da177e4SLinus Torvalds
7681da177e4SLinus Torvalds if (a && a->status & ATIF_PROBE) {
7691da177e4SLinus Torvalds a->status |= ATIF_PROBE_FAIL;
7701da177e4SLinus Torvalds /*
771d439aa33Sgushengxian * we do not respond to probe or request packets of
7721da177e4SLinus Torvalds * this address while we are probing this address
7731da177e4SLinus Torvalds */
7741da177e4SLinus Torvalds goto unlock;
7751da177e4SLinus Torvalds }
7761da177e4SLinus Torvalds
7771da177e4SLinus Torvalds switch (function) {
7781da177e4SLinus Torvalds case AARP_REPLY:
7791da177e4SLinus Torvalds if (!unresolved_count) /* Speed up */
7801da177e4SLinus Torvalds break;
7811da177e4SLinus Torvalds
7821da177e4SLinus Torvalds /* Find the entry. */
7831da177e4SLinus Torvalds a = __aarp_find_entry(unresolved[hash], dev, &sa);
7841da177e4SLinus Torvalds if (!a || dev != a->dev)
7851da177e4SLinus Torvalds break;
7861da177e4SLinus Torvalds
7871da177e4SLinus Torvalds /* We can fill one in - this is good. */
78890ccb6aaSJoe Perches ether_addr_copy(a->hwaddr, ea->hw_src);
7891da177e4SLinus Torvalds __aarp_resolved(&unresolved[hash], a, hash);
7901da177e4SLinus Torvalds if (!unresolved_count)
7911da177e4SLinus Torvalds mod_timer(&aarp_timer,
7921da177e4SLinus Torvalds jiffies + sysctl_aarp_expiry_time);
7931da177e4SLinus Torvalds break;
7941da177e4SLinus Torvalds
7951da177e4SLinus Torvalds case AARP_REQUEST:
7961da177e4SLinus Torvalds case AARP_PROBE:
7971da177e4SLinus Torvalds
7981da177e4SLinus Torvalds /*
7991da177e4SLinus Torvalds * If it is my address set ma to my address and reply.
8001da177e4SLinus Torvalds * We can treat probe and request the same. Probe
8011da177e4SLinus Torvalds * simply means we shouldn't cache the querying host,
8021da177e4SLinus Torvalds * as in a probe they are proposing an address not
8031da177e4SLinus Torvalds * using one.
8041da177e4SLinus Torvalds *
8051da177e4SLinus Torvalds * Support for proxy-AARP added. We check if the
8061da177e4SLinus Torvalds * address is one of our proxies before we toss the
8071da177e4SLinus Torvalds * packet out.
8081da177e4SLinus Torvalds */
8091da177e4SLinus Torvalds
8101da177e4SLinus Torvalds sa.s_node = ea->pa_dst_node;
8111da177e4SLinus Torvalds sa.s_net = ea->pa_dst_net;
8121da177e4SLinus Torvalds
8131da177e4SLinus Torvalds /* See if we have a matching proxy. */
8141da177e4SLinus Torvalds ma = __aarp_proxy_find(dev, &sa);
8151da177e4SLinus Torvalds if (!ma)
8161da177e4SLinus Torvalds ma = &ifa->address;
8171da177e4SLinus Torvalds else { /* We need to make a copy of the entry. */
8181da177e4SLinus Torvalds da.s_node = sa.s_node;
8192a04cd4cSRoel Kluin da.s_net = sa.s_net;
8201da177e4SLinus Torvalds ma = &da;
8211da177e4SLinus Torvalds }
8221da177e4SLinus Torvalds
8231da177e4SLinus Torvalds if (function == AARP_PROBE) {
8241da177e4SLinus Torvalds /*
8251da177e4SLinus Torvalds * A probe implies someone trying to get an
8261da177e4SLinus Torvalds * address. So as a precaution flush any
8271da177e4SLinus Torvalds * entries we have for this address.
8281da177e4SLinus Torvalds */
8291da177e4SLinus Torvalds a = __aarp_find_entry(resolved[sa.s_node %
8301da177e4SLinus Torvalds (AARP_HASH_SIZE - 1)],
8311da177e4SLinus Torvalds skb->dev, &sa);
8321da177e4SLinus Torvalds
8331da177e4SLinus Torvalds /*
8341da177e4SLinus Torvalds * Make it expire next tick - that avoids us
8351da177e4SLinus Torvalds * getting into a probe/flush/learn/probe/
8361da177e4SLinus Torvalds * flush/learn cycle during probing of a slow
8371da177e4SLinus Torvalds * to respond host addr.
8381da177e4SLinus Torvalds */
8391da177e4SLinus Torvalds if (a) {
8401da177e4SLinus Torvalds a->expires_at = jiffies - 1;
8411da177e4SLinus Torvalds mod_timer(&aarp_timer, jiffies +
8421da177e4SLinus Torvalds sysctl_aarp_tick_time);
8431da177e4SLinus Torvalds }
8441da177e4SLinus Torvalds }
8451da177e4SLinus Torvalds
8461da177e4SLinus Torvalds if (sa.s_node != ma->s_node)
8471da177e4SLinus Torvalds break;
8481da177e4SLinus Torvalds
8491da177e4SLinus Torvalds if (sa.s_net && ma->s_net && sa.s_net != ma->s_net)
8501da177e4SLinus Torvalds break;
8511da177e4SLinus Torvalds
8521da177e4SLinus Torvalds sa.s_node = ea->pa_src_node;
8531da177e4SLinus Torvalds sa.s_net = ea->pa_src_net;
8541da177e4SLinus Torvalds
8551da177e4SLinus Torvalds /* aarp_my_address has found the address to use for us.
8561da177e4SLinus Torvalds */
8571da177e4SLinus Torvalds aarp_send_reply(dev, ma, &sa, ea->hw_src);
8581da177e4SLinus Torvalds break;
8591da177e4SLinus Torvalds }
8601da177e4SLinus Torvalds
8611da177e4SLinus Torvalds unlock:
8621da177e4SLinus Torvalds write_unlock_bh(&aarp_lock);
8631da177e4SLinus Torvalds out1:
8641da177e4SLinus Torvalds ret = 1;
8651da177e4SLinus Torvalds out0:
8661da177e4SLinus Torvalds kfree_skb(skb);
8671da177e4SLinus Torvalds return ret;
8681da177e4SLinus Torvalds }
8691da177e4SLinus Torvalds
8701da177e4SLinus Torvalds static struct notifier_block aarp_notifier = {
8711da177e4SLinus Torvalds .notifier_call = aarp_device_event,
8721da177e4SLinus Torvalds };
8731da177e4SLinus Torvalds
8741da177e4SLinus Torvalds static unsigned char aarp_snap_id[] = { 0x00, 0x00, 0x00, 0x80, 0xF3 };
8751da177e4SLinus Torvalds
aarp_proto_init(void)8769804501fSYueHaibing int __init aarp_proto_init(void)
8771da177e4SLinus Torvalds {
8789804501fSYueHaibing int rc;
8799804501fSYueHaibing
8801da177e4SLinus Torvalds aarp_dl = register_snap_client(aarp_snap_id, aarp_rcv);
8819804501fSYueHaibing if (!aarp_dl) {
8821da177e4SLinus Torvalds printk(KERN_CRIT "Unable to register AARP with SNAP.\n");
8839804501fSYueHaibing return -ENOMEM;
8849804501fSYueHaibing }
885e99e88a9SKees Cook timer_setup(&aarp_timer, aarp_expire_timeout, 0);
8861da177e4SLinus Torvalds aarp_timer.expires = jiffies + sysctl_aarp_expiry_time;
8871da177e4SLinus Torvalds add_timer(&aarp_timer);
8889804501fSYueHaibing rc = register_netdevice_notifier(&aarp_notifier);
8899804501fSYueHaibing if (rc) {
8909804501fSYueHaibing del_timer_sync(&aarp_timer);
8919804501fSYueHaibing unregister_snap_client(aarp_dl);
8929804501fSYueHaibing }
8939804501fSYueHaibing return rc;
8941da177e4SLinus Torvalds }
8951da177e4SLinus Torvalds
8961da177e4SLinus Torvalds /* Remove the AARP entries associated with a device. */
aarp_device_down(struct net_device * dev)8971da177e4SLinus Torvalds void aarp_device_down(struct net_device *dev)
8981da177e4SLinus Torvalds {
8991da177e4SLinus Torvalds int ct;
9001da177e4SLinus Torvalds
9011da177e4SLinus Torvalds write_lock_bh(&aarp_lock);
9021da177e4SLinus Torvalds
9031da177e4SLinus Torvalds for (ct = 0; ct < AARP_HASH_SIZE; ct++) {
9041da177e4SLinus Torvalds __aarp_expire_device(&resolved[ct], dev);
9051da177e4SLinus Torvalds __aarp_expire_device(&unresolved[ct], dev);
9061da177e4SLinus Torvalds __aarp_expire_device(&proxies[ct], dev);
9071da177e4SLinus Torvalds }
9081da177e4SLinus Torvalds
9091da177e4SLinus Torvalds write_unlock_bh(&aarp_lock);
9101da177e4SLinus Torvalds }
9111da177e4SLinus Torvalds
9121da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS
9131da177e4SLinus Torvalds /*
9141da177e4SLinus Torvalds * Get the aarp entry that is in the chain described
9151da177e4SLinus Torvalds * by the iterator.
9161da177e4SLinus Torvalds * If pos is set then skip till that index.
9171da177e4SLinus Torvalds * pos = 1 is the first entry
9181da177e4SLinus Torvalds */
iter_next(struct aarp_iter_state * iter,loff_t * pos)9191da177e4SLinus Torvalds static struct aarp_entry *iter_next(struct aarp_iter_state *iter, loff_t *pos)
9201da177e4SLinus Torvalds {
9211da177e4SLinus Torvalds int ct = iter->bucket;
9221da177e4SLinus Torvalds struct aarp_entry **table = iter->table;
9231da177e4SLinus Torvalds loff_t off = 0;
9241da177e4SLinus Torvalds struct aarp_entry *entry;
9251da177e4SLinus Torvalds
9261da177e4SLinus Torvalds rescan:
9271da177e4SLinus Torvalds while (ct < AARP_HASH_SIZE) {
9281da177e4SLinus Torvalds for (entry = table[ct]; entry; entry = entry->next) {
9291da177e4SLinus Torvalds if (!pos || ++off == *pos) {
9301da177e4SLinus Torvalds iter->table = table;
9311da177e4SLinus Torvalds iter->bucket = ct;
9321da177e4SLinus Torvalds return entry;
9331da177e4SLinus Torvalds }
9341da177e4SLinus Torvalds }
9351da177e4SLinus Torvalds ++ct;
9361da177e4SLinus Torvalds }
9371da177e4SLinus Torvalds
9381da177e4SLinus Torvalds if (table == resolved) {
9391da177e4SLinus Torvalds ct = 0;
9401da177e4SLinus Torvalds table = unresolved;
9411da177e4SLinus Torvalds goto rescan;
9421da177e4SLinus Torvalds }
9431da177e4SLinus Torvalds if (table == unresolved) {
9441da177e4SLinus Torvalds ct = 0;
9451da177e4SLinus Torvalds table = proxies;
9461da177e4SLinus Torvalds goto rescan;
9471da177e4SLinus Torvalds }
9481da177e4SLinus Torvalds return NULL;
9491da177e4SLinus Torvalds }
9501da177e4SLinus Torvalds
aarp_seq_start(struct seq_file * seq,loff_t * pos)9511da177e4SLinus Torvalds static void *aarp_seq_start(struct seq_file *seq, loff_t *pos)
952ca629f24SEric Dumazet __acquires(aarp_lock)
9531da177e4SLinus Torvalds {
9541da177e4SLinus Torvalds struct aarp_iter_state *iter = seq->private;
9551da177e4SLinus Torvalds
9561da177e4SLinus Torvalds read_lock_bh(&aarp_lock);
9571da177e4SLinus Torvalds iter->table = resolved;
9581da177e4SLinus Torvalds iter->bucket = 0;
9591da177e4SLinus Torvalds
9601da177e4SLinus Torvalds return *pos ? iter_next(iter, pos) : SEQ_START_TOKEN;
9611da177e4SLinus Torvalds }
9621da177e4SLinus Torvalds
aarp_seq_next(struct seq_file * seq,void * v,loff_t * pos)9631da177e4SLinus Torvalds static void *aarp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
9641da177e4SLinus Torvalds {
9651da177e4SLinus Torvalds struct aarp_entry *entry = v;
9661da177e4SLinus Torvalds struct aarp_iter_state *iter = seq->private;
9671da177e4SLinus Torvalds
9681da177e4SLinus Torvalds ++*pos;
9691da177e4SLinus Torvalds
9701da177e4SLinus Torvalds /* first line after header */
9711da177e4SLinus Torvalds if (v == SEQ_START_TOKEN)
9721da177e4SLinus Torvalds entry = iter_next(iter, NULL);
9731da177e4SLinus Torvalds
9741da177e4SLinus Torvalds /* next entry in current bucket */
9751da177e4SLinus Torvalds else if (entry->next)
9761da177e4SLinus Torvalds entry = entry->next;
9771da177e4SLinus Torvalds
9781da177e4SLinus Torvalds /* next bucket or table */
9791da177e4SLinus Torvalds else {
9801da177e4SLinus Torvalds ++iter->bucket;
9811da177e4SLinus Torvalds entry = iter_next(iter, NULL);
9821da177e4SLinus Torvalds }
9831da177e4SLinus Torvalds return entry;
9841da177e4SLinus Torvalds }
9851da177e4SLinus Torvalds
aarp_seq_stop(struct seq_file * seq,void * v)9861da177e4SLinus Torvalds static void aarp_seq_stop(struct seq_file *seq, void *v)
987ca629f24SEric Dumazet __releases(aarp_lock)
9881da177e4SLinus Torvalds {
9891da177e4SLinus Torvalds read_unlock_bh(&aarp_lock);
9901da177e4SLinus Torvalds }
9911da177e4SLinus Torvalds
dt2str(unsigned long ticks)9921da177e4SLinus Torvalds static const char *dt2str(unsigned long ticks)
9931da177e4SLinus Torvalds {
9941da177e4SLinus Torvalds static char buf[32];
9951da177e4SLinus Torvalds
9961da177e4SLinus Torvalds sprintf(buf, "%ld.%02ld", ticks / HZ, ((ticks % HZ) * 100) / HZ);
9971da177e4SLinus Torvalds
9981da177e4SLinus Torvalds return buf;
9991da177e4SLinus Torvalds }
10001da177e4SLinus Torvalds
aarp_seq_show(struct seq_file * seq,void * v)10011da177e4SLinus Torvalds static int aarp_seq_show(struct seq_file *seq, void *v)
10021da177e4SLinus Torvalds {
10031da177e4SLinus Torvalds struct aarp_iter_state *iter = seq->private;
10041da177e4SLinus Torvalds struct aarp_entry *entry = v;
10051da177e4SLinus Torvalds unsigned long now = jiffies;
10061da177e4SLinus Torvalds
10071da177e4SLinus Torvalds if (v == SEQ_START_TOKEN)
10081da177e4SLinus Torvalds seq_puts(seq,
10091da177e4SLinus Torvalds "Address Interface Hardware Address"
10101da177e4SLinus Torvalds " Expires LastSend Retry Status\n");
10111da177e4SLinus Torvalds else {
10121da177e4SLinus Torvalds seq_printf(seq, "%04X:%02X %-12s",
10131da177e4SLinus Torvalds ntohs(entry->target_addr.s_net),
10141da177e4SLinus Torvalds (unsigned int) entry->target_addr.s_node,
10151da177e4SLinus Torvalds entry->dev ? entry->dev->name : "????");
1016e174961cSJohannes Berg seq_printf(seq, "%pM", entry->hwaddr);
10171da177e4SLinus Torvalds seq_printf(seq, " %8s",
10181da177e4SLinus Torvalds dt2str((long)entry->expires_at - (long)now));
10191da177e4SLinus Torvalds if (iter->table == unresolved)
10201da177e4SLinus Torvalds seq_printf(seq, " %8s %6hu",
10211da177e4SLinus Torvalds dt2str(now - entry->last_sent),
10221da177e4SLinus Torvalds entry->xmit_count);
10231da177e4SLinus Torvalds else
10241da177e4SLinus Torvalds seq_puts(seq, " ");
10251da177e4SLinus Torvalds seq_printf(seq, " %s\n",
10261da177e4SLinus Torvalds (iter->table == resolved) ? "resolved"
10271da177e4SLinus Torvalds : (iter->table == unresolved) ? "unresolved"
10281da177e4SLinus Torvalds : (iter->table == proxies) ? "proxies"
10291da177e4SLinus Torvalds : "unknown");
10301da177e4SLinus Torvalds }
10311da177e4SLinus Torvalds return 0;
10321da177e4SLinus Torvalds }
10331da177e4SLinus Torvalds
103444414d82SChristoph Hellwig const struct seq_operations aarp_seq_ops = {
10351da177e4SLinus Torvalds .start = aarp_seq_start,
10361da177e4SLinus Torvalds .next = aarp_seq_next,
10371da177e4SLinus Torvalds .stop = aarp_seq_stop,
10381da177e4SLinus Torvalds .show = aarp_seq_show,
10391da177e4SLinus Torvalds };
10401da177e4SLinus Torvalds #endif
10411da177e4SLinus Torvalds
10421da177e4SLinus Torvalds /* General module cleanup. Called from cleanup_module() in ddp.c. */
aarp_cleanup_module(void)10431da177e4SLinus Torvalds void aarp_cleanup_module(void)
10441da177e4SLinus Torvalds {
10451da177e4SLinus Torvalds del_timer_sync(&aarp_timer);
10461da177e4SLinus Torvalds unregister_netdevice_notifier(&aarp_notifier);
10471da177e4SLinus Torvalds unregister_snap_client(aarp_dl);
10481da177e4SLinus Torvalds aarp_purge();
10491da177e4SLinus Torvalds }
1050