[mirror_ubuntu-bionic-kernel.git] / net / 802 / tr.c

/*
 * NET3:	Token ring device handling subroutines
 *
 *		This program is free software; you can redistribute it and/or
 *		modify it under the terms of the GNU General Public License
 *		as published by the Free Software Foundation; either version
 *		2 of the License, or (at your option) any later version.
 *
 * Fixes:       3 Feb 97 Paul Norton <pnorton@cts.com> Minor routing fixes.
 *              Added rif table to /proc/net/tr_rif and rif timeout to
 *              /proc/sys/net/token-ring/rif_timeout.
 *              22 Jun 98 Paul Norton <p.norton@computer.org> Rearranged
 *              tr_header and tr_type_trans to handle passing IPX SNAP and
 *              802.2 through the correct layers. Eliminated tr_reformat.
 *
 */

#include <asm/uaccess.h>
#include <asm/system.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/jiffies.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/socket.h>
#include <linux/in.h>
#include <linux/inet.h>
#include <linux/netdevice.h>
#include <linux/trdevice.h>
#include <linux/skbuff.h>
#include <linux/errno.h>
#include <linux/timer.h>
#include <linux/net.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/init.h>
#include <linux/sysctl.h>
#include <net/arp.h>
#include <net/net_namespace.h>

static void tr_add_rif_info(struct trh_hdr *trh, struct net_device *dev);
static void rif_check_expire(unsigned long dummy);

#define TR_SR_DEBUG 0

/*
 *	Each RIF entry we learn is kept this way
 */

struct rif_cache {
	unsigned char addr[TR_ALEN];
	int iface;
	__be16 rcf;
	__be16 rseg[8];
	struct rif_cache *next;
	unsigned long last_used;
	unsigned char local_ring;
};

#define RIF_TABLE_SIZE 32

/*
 *	We hash the RIF cache 32 ways. We do after all have to look it
 *	up a lot.
 */

static struct rif_cache *rif_table[RIF_TABLE_SIZE];

static DEFINE_SPINLOCK(rif_lock);


/*
 *	Garbage disposal timer.
 */

static struct timer_list rif_timer;

static int sysctl_tr_rif_timeout = 60*10*HZ;

static inline unsigned long rif_hash(const unsigned char *addr)
{
	unsigned long x;

	x = addr[0];
	x = (x << 2) ^ addr[1];
	x = (x << 2) ^ addr[2];
	x = (x << 2) ^ addr[3];
	x = (x << 2) ^ addr[4];
	x = (x << 2) ^ addr[5];

	x ^= x >> 8;

	return x & (RIF_TABLE_SIZE - 1);
}

/*
 *	Put the headers on a token ring packet. Token ring source routing
 *	makes this a little more exciting than on ethernet.
 */

static int tr_header(struct sk_buff *skb, struct net_device *dev,
		     unsigned short type,
		     const void *daddr, const void *saddr, unsigned len)
{
	struct trh_hdr *trh;
	int hdr_len;

	/*
	 * Add the 802.2 SNAP header if IP as the IPv4/IPv6 code calls
	 * dev->hard_header directly.
	 */
	if (type == ETH_P_IP || type == ETH_P_IPV6 || type == ETH_P_ARP)
	{
		struct trllc *trllc;

		hdr_len = sizeof(struct trh_hdr) + sizeof(struct trllc);
		trh = (struct trh_hdr *)skb_push(skb, hdr_len);
		trllc = (struct trllc *)(trh+1);
		trllc->dsap = trllc->ssap = EXTENDED_SAP;
		trllc->llc = UI_CMD;
		trllc->protid[0] = trllc->protid[1] = trllc->protid[2] = 0x00;
		trllc->ethertype = htons(type);
	}
	else
	{
		hdr_len = sizeof(struct trh_hdr);
		trh = (struct trh_hdr *)skb_push(skb, hdr_len);
	}

	trh->ac=AC;
	trh->fc=LLC_FRAME;

	if(saddr)
		memcpy(trh->saddr,saddr,dev->addr_len);
	else
		memcpy(trh->saddr,dev->dev_addr,dev->addr_len);

	/*
	 *	Build the destination and then source route the frame
	 */

	if(daddr)
	{
		memcpy(trh->daddr,daddr,dev->addr_len);
		tr_source_route(skb, trh, dev);
		return(hdr_len);
	}

	return -hdr_len;
}

/*
 *	A neighbour discovery of some species (eg arp) has completed. We
 *	can now send the packet.
 */

static int tr_rebuild_header(struct sk_buff *skb)
{
	struct trh_hdr *trh=(struct trh_hdr *)skb->data;
	struct trllc *trllc=(struct trllc *)(skb->data+sizeof(struct trh_hdr));
	struct net_device *dev = skb->dev;

	/*
	 *	FIXME: We don't yet support IPv6 over token rings
	 */

	if(trllc->ethertype != htons(ETH_P_IP)) {
		printk("tr_rebuild_header: Don't know how to resolve type %04X addresses ?\n", ntohs(trllc->ethertype));
		return 0;
	}

#ifdef CONFIG_INET
	if(arp_find(trh->daddr, skb)) {
			return 1;
	}
	else
#endif
	{
		tr_source_route(skb,trh,dev);
		return 0;
	}
}

/*
 *	Some of this is a bit hackish. We intercept RIF information
 *	used for source routing. We also grab IP directly and don't feed
 *	it via SNAP.
 */

__be16 tr_type_trans(struct sk_buff *skb, struct net_device *dev)
{

	struct trh_hdr *trh;
	struct trllc *trllc;
	unsigned riflen=0;

	skb->dev = dev;
	skb_reset_mac_header(skb);
	trh = tr_hdr(skb);

	if(trh->saddr[0] & TR_RII)
		riflen = (ntohs(trh->rcf) & TR_RCF_LEN_MASK) >> 8;

	trllc = (struct trllc *)(skb->data+sizeof(struct trh_hdr)-TR_MAXRIFLEN+riflen);

	skb_pull(skb,sizeof(struct trh_hdr)-TR_MAXRIFLEN+riflen);

	if(*trh->daddr & 0x80)
	{
		if(!memcmp(trh->daddr,dev->broadcast,TR_ALEN))
			skb->pkt_type=PACKET_BROADCAST;
		else
			skb->pkt_type=PACKET_MULTICAST;
	}
	else if ( (trh->daddr[0] & 0x01) && (trh->daddr[1] & 0x00) && (trh->daddr[2] & 0x5E))
	{
		skb->pkt_type=PACKET_MULTICAST;
	}
	else if(dev->flags & IFF_PROMISC)
	{
		if(memcmp(trh->daddr, dev->dev_addr, TR_ALEN))
			skb->pkt_type=PACKET_OTHERHOST;
	}

	if ((skb->pkt_type != PACKET_BROADCAST) &&
	    (skb->pkt_type != PACKET_MULTICAST))
		tr_add_rif_info(trh,dev) ;

	/*
	 * Strip the SNAP header from ARP packets since we don't
	 * pass them through to the 802.2/SNAP layers.
	 */

	if (trllc->dsap == EXTENDED_SAP &&
	    (trllc->ethertype == htons(ETH_P_IP) ||
	     trllc->ethertype == htons(ETH_P_IPV6) ||
	     trllc->ethertype == htons(ETH_P_ARP)))
	{
		skb_pull(skb, sizeof(struct trllc));
		return trllc->ethertype;
	}

	return htons(ETH_P_TR_802_2);
}

/*
 *	We try to do source routing...
 */

void tr_source_route(struct sk_buff *skb,struct trh_hdr *trh,
		     struct net_device *dev)
{
	int slack;
	unsigned int hash;
	struct rif_cache *entry;
	unsigned char *olddata;
	unsigned long flags;
	static const unsigned char mcast_func_addr[]
		= {0xC0,0x00,0x00,0x04,0x00,0x00};

	spin_lock_irqsave(&rif_lock, flags);

	/*
	 *	Broadcasts are single route as stated in RFC 1042
	 */
	if( (!memcmp(&(trh->daddr[0]),&(dev->broadcast[0]),TR_ALEN)) ||
	    (!memcmp(&(trh->daddr[0]),&(mcast_func_addr[0]), TR_ALEN))  )
	{
		trh->rcf=htons((((sizeof(trh->rcf)) << 8) & TR_RCF_LEN_MASK)
			       | TR_RCF_FRAME2K | TR_RCF_LIMITED_BROADCAST);
		trh->saddr[0]|=TR_RII;
	}
	else
	{
		hash = rif_hash(trh->daddr);
		/*
		 *	Walk the hash table and look for an entry
		 */
		for(entry=rif_table[hash];entry && memcmp(&(entry->addr[0]),&(trh->daddr[0]),TR_ALEN);entry=entry->next);

		/*
		 *	If we found an entry we can route the frame.
		 */
		if(entry)
		{
#if TR_SR_DEBUG
{
DECLARE_MAC_BUF(mac);
printk("source routing for %s\n",print_mac(mac, trh->daddr));
}
#endif
			if(!entry->local_ring && (ntohs(entry->rcf) & TR_RCF_LEN_MASK) >> 8)
			{
				trh->rcf=entry->rcf;
				memcpy(&trh->rseg[0],&entry->rseg[0],8*sizeof(unsigned short));
				trh->rcf^=htons(TR_RCF_DIR_BIT);
				trh->rcf&=htons(0x1fff);	/* Issam Chehab <ichehab@madge1.demon.co.uk> */

				trh->saddr[0]|=TR_RII;
#if TR_SR_DEBUG
				printk("entry found with rcf %04x\n", entry->rcf);
			}
			else
			{
				printk("entry found but without rcf length, local=%02x\n", entry->local_ring);
#endif
			}
			entry->last_used=jiffies;
		}
		else
		{
			/*
			 *	Without the information we simply have to shout
			 *	on the wire. The replies should rapidly clean this
			 *	situation up.
			 */
			trh->rcf=htons((((sizeof(trh->rcf)) << 8) & TR_RCF_LEN_MASK)
				       | TR_RCF_FRAME2K | TR_RCF_LIMITED_BROADCAST);
			trh->saddr[0]|=TR_RII;
#if TR_SR_DEBUG
			printk("no entry in rif table found - broadcasting frame\n");
#endif
		}
	}

	/* Compress the RIF here so we don't have to do it in the driver(s) */
	if (!(trh->saddr[0] & 0x80))
		slack = 18;
	else
		slack = 18 - ((ntohs(trh->rcf) & TR_RCF_LEN_MASK)>>8);
	olddata = skb->data;
	spin_unlock_irqrestore(&rif_lock, flags);

	skb_pull(skb, slack);
	memmove(skb->data, olddata, sizeof(struct trh_hdr) - slack);
}

/*
 *	We have learned some new RIF information for our source
 *	routing.
 */

static void tr_add_rif_info(struct trh_hdr *trh, struct net_device *dev)
{
	unsigned int hash, rii_p = 0;
	unsigned long flags;
	struct rif_cache *entry;
	unsigned char saddr0;

	spin_lock_irqsave(&rif_lock, flags);
	saddr0 = trh->saddr[0];

	/*
	 *	Firstly see if the entry exists
	 */

	if(trh->saddr[0] & TR_RII)
	{
		trh->saddr[0]&=0x7f;
		if (((ntohs(trh->rcf) & TR_RCF_LEN_MASK) >> 8) > 2)
		{
			rii_p = 1;
		}
	}

	hash = rif_hash(trh->saddr);
	for(entry=rif_table[hash];entry && memcmp(&(entry->addr[0]),&(trh->saddr[0]),TR_ALEN);entry=entry->next);

	if(entry==NULL)
	{
#if TR_SR_DEBUG
		DECLARE_MAC_BUF(mac);
		printk("adding rif_entry: addr:%s rcf:%04X\n",
		       print_mac(mac, trh->saddr), ntohs(trh->rcf));
#endif
		/*
		 *	Allocate our new entry. A failure to allocate loses
		 *	use the information. This is harmless.
		 *
		 *	FIXME: We ought to keep some kind of cache size
		 *	limiting and adjust the timers to suit.
		 */
		entry=kmalloc(sizeof(struct rif_cache),GFP_ATOMIC);

		if(!entry)
		{
			printk(KERN_DEBUG "tr.c: Couldn't malloc rif cache entry !\n");
			spin_unlock_irqrestore(&rif_lock, flags);
			return;
		}

		memcpy(&(entry->addr[0]),&(trh->saddr[0]),TR_ALEN);
		entry->iface = dev->ifindex;
		entry->next=rif_table[hash];
		entry->last_used=jiffies;
		rif_table[hash]=entry;

		if (rii_p)
		{
			entry->rcf = trh->rcf & htons((unsigned short)~TR_RCF_BROADCAST_MASK);
			memcpy(&(entry->rseg[0]),&(trh->rseg[0]),8*sizeof(unsigned short));
			entry->local_ring = 0;
		}
		else
		{
			entry->local_ring = 1;
		}
	}
	else	/* Y. Tahara added */
	{
		/*
		 *	Update existing entries
		 */
		if (!entry->local_ring)
		    if (entry->rcf != (trh->rcf & htons((unsigned short)~TR_RCF_BROADCAST_MASK)) &&
			 !(trh->rcf & htons(TR_RCF_BROADCAST_MASK)))
		    {
#if TR_SR_DEBUG
{
DECLARE_MAC_BUF(mac);
printk("updating rif_entry: addr:%s rcf:%04X\n",
		print_mac(mac, trh->saddr), ntohs(trh->rcf));
}
#endif
			    entry->rcf = trh->rcf & htons((unsigned short)~TR_RCF_BROADCAST_MASK);
			    memcpy(&(entry->rseg[0]),&(trh->rseg[0]),8*sizeof(unsigned short));
		    }
		entry->last_used=jiffies;
	}
	trh->saddr[0]=saddr0; /* put the routing indicator back for tcpdump */
	spin_unlock_irqrestore(&rif_lock, flags);
}

/*
 *	Scan the cache with a timer and see what we need to throw out.
 */

static void rif_check_expire(unsigned long dummy)
{
	int i;
	unsigned long flags, next_interval = jiffies + sysctl_tr_rif_timeout/2;

	spin_lock_irqsave(&rif_lock, flags);

	for(i =0; i < RIF_TABLE_SIZE; i++) {
		struct rif_cache *entry, **pentry;

		pentry = rif_table+i;
		while((entry=*pentry) != NULL) {
			unsigned long expires
				= entry->last_used + sysctl_tr_rif_timeout;

			if (time_before_eq(expires, jiffies)) {
				*pentry = entry->next;
				kfree(entry);
			} else {
				pentry = &entry->next;

				if (time_before(expires, next_interval))
					next_interval = expires;
			}
		}
	}

	spin_unlock_irqrestore(&rif_lock, flags);

	mod_timer(&rif_timer, next_interval);

}

/*
 *	Generate the /proc/net information for the token ring RIF
 *	routing.
 */

#ifdef CONFIG_PROC_FS

static struct rif_cache *rif_get_idx(loff_t pos)
{
	int i;
	struct rif_cache *entry;
	loff_t off = 0;

	for(i = 0; i < RIF_TABLE_SIZE; i++)
		for(entry = rif_table[i]; entry; entry = entry->next) {
			if (off == pos)
				return entry;
			++off;
		}

	return NULL;
}

static void *rif_seq_start(struct seq_file *seq, loff_t *pos)
{
	spin_lock_irq(&rif_lock);

	return *pos ? rif_get_idx(*pos - 1) : SEQ_START_TOKEN;
}

static void *rif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
	int i;
	struct rif_cache *ent = v;

	++*pos;

	if (v == SEQ_START_TOKEN) {
		i = -1;
		goto scan;
	}

	if (ent->next)
		return ent->next;

	i = rif_hash(ent->addr);
 scan:
	while (++i < RIF_TABLE_SIZE) {
		if ((ent = rif_table[i]) != NULL)
			return ent;
	}
	return NULL;
}

static void rif_seq_stop(struct seq_file *seq, void *v)
{
	spin_unlock_irq(&rif_lock);
}

static int rif_seq_show(struct seq_file *seq, void *v)
{
	int j, rcf_len, segment, brdgnmb;
	struct rif_cache *entry = v;
	DECLARE_MAC_BUF(mac);

	if (v == SEQ_START_TOKEN)
		seq_puts(seq,
		     "if     TR address       TTL   rcf   routing segments\n");
	else {
		struct net_device *dev = dev_get_by_index(&init_net, entry->iface);
		long ttl = (long) (entry->last_used + sysctl_tr_rif_timeout)
				- (long) jiffies;

		seq_printf(seq, "%s %s %7li ",
			   dev?dev->name:"?",
			   print_mac(mac, entry->addr),
			   ttl/HZ);

			if (entry->local_ring)
				seq_puts(seq, "local\n");
			else {

				seq_printf(seq, "%04X", ntohs(entry->rcf));
				rcf_len = ((ntohs(entry->rcf) & TR_RCF_LEN_MASK)>>8)-2;
				if (rcf_len)
					rcf_len >>= 1;
				for(j = 1; j < rcf_len; j++) {
					if(j==1) {
						segment=ntohs(entry->rseg[j-1])>>4;
						seq_printf(seq,"  %03X",segment);
					}

					segment=ntohs(entry->rseg[j])>>4;
					brdgnmb=ntohs(entry->rseg[j-1])&0x00f;
					seq_printf(seq,"-%01X-%03X",brdgnmb,segment);
				}
				seq_putc(seq, '\n');
			}
		}
	return 0;
}


static const struct seq_operations rif_seq_ops = {
	.start = rif_seq_start,
	.next  = rif_seq_next,
	.stop  = rif_seq_stop,
	.show  = rif_seq_show,
};

static int rif_seq_open(struct inode *inode, struct file *file)
{
	return seq_open(file, &rif_seq_ops);
}

static const struct file_operations rif_seq_fops = {
	.owner	 = THIS_MODULE,
	.open    = rif_seq_open,
	.read    = seq_read,
	.llseek  = seq_lseek,
	.release = seq_release,
};

#endif

static const struct header_ops tr_header_ops = {
	.create = tr_header,
	.rebuild= tr_rebuild_header,
};

static void tr_setup(struct net_device *dev)
{
	/*
	 *	Configure and register
	 */

	dev->header_ops	= &tr_header_ops;

	dev->type		= ARPHRD_IEEE802_TR;
	dev->hard_header_len	= TR_HLEN;
	dev->mtu		= 2000;
	dev->addr_len		= TR_ALEN;
	dev->tx_queue_len	= 100;	/* Long queues on tr */

	memset(dev->broadcast,0xFF, TR_ALEN);

	/* New-style flags. */
	dev->flags		= IFF_BROADCAST | IFF_MULTICAST ;
}

/**
 * alloc_trdev - Register token ring device
 * @sizeof_priv: Size of additional driver-private structure to be allocated
 *	for this token ring device
 *
 * Fill in the fields of the device structure with token ring-generic values.
 *
 * Constructs a new net device, complete with a private data area of
 * size @sizeof_priv.  A 32-byte (not bit) alignment is enforced for
 * this private data area.
 */
struct net_device *alloc_trdev(int sizeof_priv)
{
	return alloc_netdev(sizeof_priv, "tr%d", tr_setup);
}

#ifdef CONFIG_SYSCTL
static struct ctl_table tr_table[] = {
	{
		.ctl_name	= NET_TR_RIF_TIMEOUT,
		.procname	= "rif_timeout",
		.data		= &sysctl_tr_rif_timeout,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= &proc_dointvec
	},
	{ 0 },
};

static __initdata struct ctl_path tr_path[] = {
	{ .procname = "net", .ctl_name = CTL_NET, },
	{ .procname = "token-ring", .ctl_name = NET_TR, },
	{ }
};
#endif

/*
 *	Called during bootup.  We don't actually have to initialise
 *	too much for this.
 */

static int __init rif_init(void)
{
	rif_timer.expires  = jiffies + sysctl_tr_rif_timeout;
	setup_timer(&rif_timer, rif_check_expire, 0);
	add_timer(&rif_timer);
#ifdef CONFIG_SYSCTL
	register_sysctl_paths(tr_path, tr_table);
#endif
	proc_net_fops_create(&init_net, "tr_rif", S_IRUGO, &rif_seq_fops);
	return 0;
}

module_init(rif_init);

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