1/*
2 * NET3:	Token ring device handling subroutines
3 *
4 *		This program is free software; you can redistribute it and/or
5 *		modify it under the terms of the GNU General Public License
6 *		as published by the Free Software Foundation; either version
7 *		2 of the License, or (at your option) any later version.
8 *
9 * Fixes:       3 Feb 97 Paul Norton <pnorton@cts.com> Minor routing fixes.
10 *              Added rif table to /proc/net/tr_rif and rif timeout to
11 *              /proc/sys/net/token-ring/rif_timeout.
12 *              22 Jun 98 Paul Norton <p.norton@computer.org> Rearranged
13 *              tr_header and tr_type_trans to handle passing IPX SNAP and
14 *              802.2 through the correct layers. Eliminated tr_reformat.
15 *
16 */
17
18#include <asm/uaccess.h>
19#include <asm/system.h>
20#include <linux/module.h>
21#include <linux/types.h>
22#include <linux/kernel.h>
23#include <linux/jiffies.h>
24#include <linux/string.h>
25#include <linux/mm.h>
26#include <linux/socket.h>
27#include <linux/in.h>
28#include <linux/inet.h>
29#include <linux/netdevice.h>
30#include <linux/trdevice.h>
31#include <linux/skbuff.h>
32#include <linux/errno.h>
33#include <linux/timer.h>
34#include <linux/net.h>
35#include <linux/proc_fs.h>
36#include <linux/seq_file.h>
37#include <linux/init.h>
38#include <linux/sysctl.h>
39#include <linux/slab.h>
40#include <net/arp.h>
41#include <net/net_namespace.h>
42
43static void tr_add_rif_info(struct trh_hdr *trh, struct net_device *dev);
44static void rif_check_expire(unsigned long dummy);
45
46#define TR_SR_DEBUG 0
47
48/*
49 *	Each RIF entry we learn is kept this way
50 */
51
52struct rif_cache {
53	unsigned char addr[TR_ALEN];
54	int iface;
55	__be16 rcf;
56	__be16 rseg[8];
57	struct rif_cache *next;
58	unsigned long last_used;
59	unsigned char local_ring;
60};
61
62#define RIF_TABLE_SIZE 32
63
64/*
65 *	We hash the RIF cache 32 ways. We do after all have to look it
66 *	up a lot.
67 */
68
69static struct rif_cache *rif_table[RIF_TABLE_SIZE];
70
71static DEFINE_SPINLOCK(rif_lock);
72
73
74/*
75 *	Garbage disposal timer.
76 */
77
78static struct timer_list rif_timer;
79
80static int sysctl_tr_rif_timeout = 60*10*HZ;
81
82static inline unsigned long rif_hash(const unsigned char *addr)
83{
84	unsigned long x;
85
86	x = addr[0];
87	x = (x << 2) ^ addr[1];
88	x = (x << 2) ^ addr[2];
89	x = (x << 2) ^ addr[3];
90	x = (x << 2) ^ addr[4];
91	x = (x << 2) ^ addr[5];
92
93	x ^= x >> 8;
94
95	return x & (RIF_TABLE_SIZE - 1);
96}
97
98/*
99 *	Put the headers on a token ring packet. Token ring source routing
100 *	makes this a little more exciting than on ethernet.
101 */
102
103static int tr_header(struct sk_buff *skb, struct net_device *dev,
104		     unsigned short type,
105		     const void *daddr, const void *saddr, unsigned len)
106{
107	struct trh_hdr *trh;
108	int hdr_len;
109
110	/*
111	 * Add the 802.2 SNAP header if IP as the IPv4/IPv6 code calls
112	 * dev->hard_header directly.
113	 */
114	if (type == ETH_P_IP || type == ETH_P_IPV6 || type == ETH_P_ARP)
115	{
116		struct trllc *trllc;
117
118		hdr_len = sizeof(struct trh_hdr) + sizeof(struct trllc);
119		trh = (struct trh_hdr *)skb_push(skb, hdr_len);
120		trllc = (struct trllc *)(trh+1);
121		trllc->dsap = trllc->ssap = EXTENDED_SAP;
122		trllc->llc = UI_CMD;
123		trllc->protid[0] = trllc->protid[1] = trllc->protid[2] = 0x00;
124		trllc->ethertype = htons(type);
125	}
126	else
127	{
128		hdr_len = sizeof(struct trh_hdr);
129		trh = (struct trh_hdr *)skb_push(skb, hdr_len);
130	}
131
132	trh->ac=AC;
133	trh->fc=LLC_FRAME;
134
135	if(saddr)
136		memcpy(trh->saddr,saddr,dev->addr_len);
137	else
138		memcpy(trh->saddr,dev->dev_addr,dev->addr_len);
139
140	/*
141	 *	Build the destination and then source route the frame
142	 */
143
144	if(daddr)
145	{
146		memcpy(trh->daddr,daddr,dev->addr_len);
147		tr_source_route(skb, trh, dev);
148		return(hdr_len);
149	}
150
151	return -hdr_len;
152}
153
154/*
155 *	A neighbour discovery of some species (eg arp) has completed. We
156 *	can now send the packet.
157 */
158
159static int tr_rebuild_header(struct sk_buff *skb)
160{
161	struct trh_hdr *trh=(struct trh_hdr *)skb->data;
162	struct trllc *trllc=(struct trllc *)(skb->data+sizeof(struct trh_hdr));
163	struct net_device *dev = skb->dev;
164
165
166	if(trllc->ethertype != htons(ETH_P_IP)) {
167		printk("tr_rebuild_header: Don't know how to resolve type %04X addresses ?\n", ntohs(trllc->ethertype));
168		return 0;
169	}
170
171#ifdef CONFIG_INET
172	if(arp_find(trh->daddr, skb)) {
173			return 1;
174	}
175	else
176#endif
177	{
178		tr_source_route(skb,trh,dev);
179		return 0;
180	}
181}
182
183/*
184 *	Some of this is a bit hackish. We intercept RIF information
185 *	used for source routing. We also grab IP directly and don't feed
186 *	it via SNAP.
187 */
188
189__be16 tr_type_trans(struct sk_buff *skb, struct net_device *dev)
190{
191
192	struct trh_hdr *trh;
193	struct trllc *trllc;
194	unsigned riflen=0;
195
196	skb->dev = dev;
197	skb_reset_mac_header(skb);
198	trh = tr_hdr(skb);
199
200	if(trh->saddr[0] & TR_RII)
201		riflen = (ntohs(trh->rcf) & TR_RCF_LEN_MASK) >> 8;
202
203	trllc = (struct trllc *)(skb->data+sizeof(struct trh_hdr)-TR_MAXRIFLEN+riflen);
204
205	skb_pull(skb,sizeof(struct trh_hdr)-TR_MAXRIFLEN+riflen);
206
207	if(*trh->daddr & 0x80)
208	{
209		if(!memcmp(trh->daddr,dev->broadcast,TR_ALEN))
210			skb->pkt_type=PACKET_BROADCAST;
211		else
212			skb->pkt_type=PACKET_MULTICAST;
213	}
214	else if ( (trh->daddr[0] & 0x01) && (trh->daddr[1] & 0x00) && (trh->daddr[2] & 0x5E))
215	{
216		skb->pkt_type=PACKET_MULTICAST;
217	}
218	else if(dev->flags & IFF_PROMISC)
219	{
220		if(memcmp(trh->daddr, dev->dev_addr, TR_ALEN))
221			skb->pkt_type=PACKET_OTHERHOST;
222	}
223
224	if ((skb->pkt_type != PACKET_BROADCAST) &&
225	    (skb->pkt_type != PACKET_MULTICAST))
226		tr_add_rif_info(trh,dev) ;
227
228	/*
229	 * Strip the SNAP header from ARP packets since we don't
230	 * pass them through to the 802.2/SNAP layers.
231	 */
232
233	if (trllc->dsap == EXTENDED_SAP &&
234	    (trllc->ethertype == htons(ETH_P_IP) ||
235	     trllc->ethertype == htons(ETH_P_IPV6) ||
236	     trllc->ethertype == htons(ETH_P_ARP)))
237	{
238		skb_pull(skb, sizeof(struct trllc));
239		return trllc->ethertype;
240	}
241
242	return htons(ETH_P_TR_802_2);
243}
244
245/*
246 *	We try to do source routing...
247 */
248
249void tr_source_route(struct sk_buff *skb,struct trh_hdr *trh,
250		     struct net_device *dev)
251{
252	int slack;
253	unsigned int hash;
254	struct rif_cache *entry;
255	unsigned char *olddata;
256	unsigned long flags;
257	static const unsigned char mcast_func_addr[]
258		= {0xC0,0x00,0x00,0x04,0x00,0x00};
259
260	spin_lock_irqsave(&rif_lock, flags);
261
262	/*
263	 *	Broadcasts are single route as stated in RFC 1042
264	 */
265	if( (!memcmp(&(trh->daddr[0]),&(dev->broadcast[0]),TR_ALEN)) ||
266	    (!memcmp(&(trh->daddr[0]),&(mcast_func_addr[0]), TR_ALEN))  )
267	{
268		trh->rcf=htons((((sizeof(trh->rcf)) << 8) & TR_RCF_LEN_MASK)
269			       | TR_RCF_FRAME2K | TR_RCF_LIMITED_BROADCAST);
270		trh->saddr[0]|=TR_RII;
271	}
272	else
273	{
274		hash = rif_hash(trh->daddr);
275		/*
276		 *	Walk the hash table and look for an entry
277		 */
278		for(entry=rif_table[hash];entry && memcmp(&(entry->addr[0]),&(trh->daddr[0]),TR_ALEN);entry=entry->next);
279
280		/*
281		 *	If we found an entry we can route the frame.
282		 */
283		if(entry)
284		{
285#if TR_SR_DEBUG
286printk("source routing for %pM\n", trh->daddr);
287#endif
288			if(!entry->local_ring && (ntohs(entry->rcf) & TR_RCF_LEN_MASK) >> 8)
289			{
290				trh->rcf=entry->rcf;
291				memcpy(&trh->rseg[0],&entry->rseg[0],8*sizeof(unsigned short));
292				trh->rcf^=htons(TR_RCF_DIR_BIT);
293				trh->rcf&=htons(0x1fff);	/* Issam Chehab <ichehab@madge1.demon.co.uk> */
294
295				trh->saddr[0]|=TR_RII;
296#if TR_SR_DEBUG
297				printk("entry found with rcf %04x\n", entry->rcf);
298			}
299			else
300			{
301				printk("entry found but without rcf length, local=%02x\n", entry->local_ring);
302#endif
303			}
304			entry->last_used=jiffies;
305		}
306		else
307		{
308			/*
309			 *	Without the information we simply have to shout
310			 *	on the wire. The replies should rapidly clean this
311			 *	situation up.
312			 */
313			trh->rcf=htons((((sizeof(trh->rcf)) << 8) & TR_RCF_LEN_MASK)
314				       | TR_RCF_FRAME2K | TR_RCF_LIMITED_BROADCAST);
315			trh->saddr[0]|=TR_RII;
316#if TR_SR_DEBUG
317			printk("no entry in rif table found - broadcasting frame\n");
318#endif
319		}
320	}
321
322	/* Compress the RIF here so we don't have to do it in the driver(s) */
323	if (!(trh->saddr[0] & 0x80))
324		slack = 18;
325	else
326		slack = 18 - ((ntohs(trh->rcf) & TR_RCF_LEN_MASK)>>8);
327	olddata = skb->data;
328	spin_unlock_irqrestore(&rif_lock, flags);
329
330	skb_pull(skb, slack);
331	memmove(skb->data, olddata, sizeof(struct trh_hdr) - slack);
332}
333
334/*
335 *	We have learned some new RIF information for our source
336 *	routing.
337 */
338
339static void tr_add_rif_info(struct trh_hdr *trh, struct net_device *dev)
340{
341	unsigned int hash, rii_p = 0;
342	unsigned long flags;
343	struct rif_cache *entry;
344	unsigned char saddr0;
345
346	spin_lock_irqsave(&rif_lock, flags);
347	saddr0 = trh->saddr[0];
348
349	/*
350	 *	Firstly see if the entry exists
351	 */
352
353	if(trh->saddr[0] & TR_RII)
354	{
355		trh->saddr[0]&=0x7f;
356		if (((ntohs(trh->rcf) & TR_RCF_LEN_MASK) >> 8) > 2)
357		{
358			rii_p = 1;
359		}
360	}
361
362	hash = rif_hash(trh->saddr);
363	for(entry=rif_table[hash];entry && memcmp(&(entry->addr[0]),&(trh->saddr[0]),TR_ALEN);entry=entry->next);
364
365	if(entry==NULL)
366	{
367#if TR_SR_DEBUG
368		printk("adding rif_entry: addr:%pM rcf:%04X\n",
369		       trh->saddr, ntohs(trh->rcf));
370#endif
371		entry=kmalloc(sizeof(struct rif_cache),GFP_ATOMIC);
372
373		if(!entry)
374		{
375			printk(KERN_DEBUG "tr.c: Couldn't malloc rif cache entry !\n");
376			spin_unlock_irqrestore(&rif_lock, flags);
377			return;
378		}
379
380		memcpy(&(entry->addr[0]),&(trh->saddr[0]),TR_ALEN);
381		entry->iface = dev->ifindex;
382		entry->next=rif_table[hash];
383		entry->last_used=jiffies;
384		rif_table[hash]=entry;
385
386		if (rii_p)
387		{
388			entry->rcf = trh->rcf & htons((unsigned short)~TR_RCF_BROADCAST_MASK);
389			memcpy(&(entry->rseg[0]),&(trh->rseg[0]),8*sizeof(unsigned short));
390			entry->local_ring = 0;
391		}
392		else
393		{
394			entry->local_ring = 1;
395		}
396	}
397	else	/* Y. Tahara added */
398	{
399		/*
400		 *	Update existing entries
401		 */
402		if (!entry->local_ring)
403		    if (entry->rcf != (trh->rcf & htons((unsigned short)~TR_RCF_BROADCAST_MASK)) &&
404			 !(trh->rcf & htons(TR_RCF_BROADCAST_MASK)))
405		    {
406#if TR_SR_DEBUG
407printk("updating rif_entry: addr:%pM rcf:%04X\n",
408		trh->saddr, ntohs(trh->rcf));
409#endif
410			    entry->rcf = trh->rcf & htons((unsigned short)~TR_RCF_BROADCAST_MASK);
411			    memcpy(&(entry->rseg[0]),&(trh->rseg[0]),8*sizeof(unsigned short));
412		    }
413		entry->last_used=jiffies;
414	}
415	trh->saddr[0]=saddr0; /* put the routing indicator back for tcpdump */
416	spin_unlock_irqrestore(&rif_lock, flags);
417}
418
419/*
420 *	Scan the cache with a timer and see what we need to throw out.
421 */
422
423static void rif_check_expire(unsigned long dummy)
424{
425	int i;
426	unsigned long flags, next_interval = jiffies + sysctl_tr_rif_timeout/2;
427
428	spin_lock_irqsave(&rif_lock, flags);
429
430	for(i =0; i < RIF_TABLE_SIZE; i++) {
431		struct rif_cache *entry, **pentry;
432
433		pentry = rif_table+i;
434		while((entry=*pentry) != NULL) {
435			unsigned long expires
436				= entry->last_used + sysctl_tr_rif_timeout;
437
438			if (time_before_eq(expires, jiffies)) {
439				*pentry = entry->next;
440				kfree(entry);
441			} else {
442				pentry = &entry->next;
443
444				if (time_before(expires, next_interval))
445					next_interval = expires;
446			}
447		}
448	}
449
450	spin_unlock_irqrestore(&rif_lock, flags);
451
452	mod_timer(&rif_timer, next_interval);
453
454}
455
456/*
457 *	Generate the /proc/net information for the token ring RIF
458 *	routing.
459 */
460
461#ifdef CONFIG_PROC_FS
462
463static struct rif_cache *rif_get_idx(loff_t pos)
464{
465	int i;
466	struct rif_cache *entry;
467	loff_t off = 0;
468
469	for(i = 0; i < RIF_TABLE_SIZE; i++)
470		for(entry = rif_table[i]; entry; entry = entry->next) {
471			if (off == pos)
472				return entry;
473			++off;
474		}
475
476	return NULL;
477}
478
479static void *rif_seq_start(struct seq_file *seq, loff_t *pos)
480	__acquires(&rif_lock)
481{
482	spin_lock_irq(&rif_lock);
483
484	return *pos ? rif_get_idx(*pos - 1) : SEQ_START_TOKEN;
485}
486
487static void *rif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
488{
489	int i;
490	struct rif_cache *ent = v;
491
492	++*pos;
493
494	if (v == SEQ_START_TOKEN) {
495		i = -1;
496		goto scan;
497	}
498
499	if (ent->next)
500		return ent->next;
501
502	i = rif_hash(ent->addr);
503 scan:
504	while (++i < RIF_TABLE_SIZE) {
505		if ((ent = rif_table[i]) != NULL)
506			return ent;
507	}
508	return NULL;
509}
510
511static void rif_seq_stop(struct seq_file *seq, void *v)
512	__releases(&rif_lock)
513{
514	spin_unlock_irq(&rif_lock);
515}
516
517static int rif_seq_show(struct seq_file *seq, void *v)
518{
519	int j, rcf_len, segment, brdgnmb;
520	struct rif_cache *entry = v;
521
522	if (v == SEQ_START_TOKEN)
523		seq_puts(seq,
524		     "if     TR address       TTL   rcf   routing segments\n");
525	else {
526		struct net_device *dev = dev_get_by_index(&init_net, entry->iface);
527		long ttl = (long) (entry->last_used + sysctl_tr_rif_timeout)
528				- (long) jiffies;
529
530		seq_printf(seq, "%s %pM %7li ",
531			   dev?dev->name:"?",
532			   entry->addr,
533			   ttl/HZ);
534
535			if (entry->local_ring)
536				seq_puts(seq, "local\n");
537			else {
538
539				seq_printf(seq, "%04X", ntohs(entry->rcf));
540				rcf_len = ((ntohs(entry->rcf) & TR_RCF_LEN_MASK)>>8)-2;
541				if (rcf_len)
542					rcf_len >>= 1;
543				for(j = 1; j < rcf_len; j++) {
544					if(j==1) {
545						segment=ntohs(entry->rseg[j-1])>>4;
546						seq_printf(seq,"  %03X",segment);
547					}
548
549					segment=ntohs(entry->rseg[j])>>4;
550					brdgnmb=ntohs(entry->rseg[j-1])&0x00f;
551					seq_printf(seq,"-%01X-%03X",brdgnmb,segment);
552				}
553				seq_putc(seq, '\n');
554			}
555
556		if (dev)
557			dev_put(dev);
558		}
559	return 0;
560}
561
562
563static const struct seq_operations rif_seq_ops = {
564	.start = rif_seq_start,
565	.next  = rif_seq_next,
566	.stop  = rif_seq_stop,
567	.show  = rif_seq_show,
568};
569
570static int rif_seq_open(struct inode *inode, struct file *file)
571{
572	return seq_open(file, &rif_seq_ops);
573}
574
575static const struct file_operations rif_seq_fops = {
576	.owner	 = THIS_MODULE,
577	.open    = rif_seq_open,
578	.read    = seq_read,
579	.llseek  = seq_lseek,
580	.release = seq_release,
581};
582
583#endif
584
585static const struct header_ops tr_header_ops = {
586	.create = tr_header,
587	.rebuild= tr_rebuild_header,
588};
589
590static void tr_setup(struct net_device *dev)
591{
592	/*
593	 *	Configure and register
594	 */
595
596	dev->header_ops	= &tr_header_ops;
597
598	dev->type		= ARPHRD_IEEE802_TR;
599	dev->hard_header_len	= TR_HLEN;
600	dev->mtu		= 2000;
601	dev->addr_len		= TR_ALEN;
602	dev->tx_queue_len	= 100;	/* Long queues on tr */
603
604	memset(dev->broadcast,0xFF, TR_ALEN);
605
606	/* New-style flags. */
607	dev->flags		= IFF_BROADCAST | IFF_MULTICAST ;
608}
609
610/**
611 * alloc_trdev - Register token ring device
612 * @sizeof_priv: Size of additional driver-private structure to be allocated
613 *	for this token ring device
614 *
615 * Fill in the fields of the device structure with token ring-generic values.
616 *
617 * Constructs a new net device, complete with a private data area of
618 * size @sizeof_priv.  A 32-byte (not bit) alignment is enforced for
619 * this private data area.
620 */
621struct net_device *alloc_trdev(int sizeof_priv)
622{
623	return alloc_netdev(sizeof_priv, "tr%d", tr_setup);
624}
625
626#ifdef CONFIG_SYSCTL
627static struct ctl_table tr_table[] = {
628	{
629		.procname	= "rif_timeout",
630		.data		= &sysctl_tr_rif_timeout,
631		.maxlen		= sizeof(int),
632		.mode		= 0644,
633		.proc_handler	= proc_dointvec
634	},
635	{ },
636};
637
638static __initdata struct ctl_path tr_path[] = {
639	{ .procname = "net", },
640	{ .procname = "token-ring", },
641	{ }
642};
643#endif
644
645/*
646 *	Called during bootup.  We don't actually have to initialise
647 *	too much for this.
648 */
649
650static int __init rif_init(void)
651{
652	rif_timer.expires  = jiffies + sysctl_tr_rif_timeout;
653	setup_timer(&rif_timer, rif_check_expire, 0);
654	add_timer(&rif_timer);
655#ifdef CONFIG_SYSCTL
656	register_sysctl_paths(tr_path, tr_table);
657#endif
658	proc_net_fops_create(&init_net, "tr_rif", S_IRUGO, &rif_seq_fops);
659	return 0;
660}
661
662module_init(rif_init);
663
664EXPORT_SYMBOL(tr_type_trans);
665EXPORT_SYMBOL(alloc_trdev);
666
667MODULE_LICENSE("GPL");
668