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