Subversion Repositories or1k

#include <asm/segment.h>
#include <asm/system.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/sched.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/string.h>
#include <linux/timer.h>
#include <linux/net.h>
#include <net/arp.h>
 
static void tr_source_route(struct trh_hdr *trh,struct device *dev);
static void tr_add_rif_info(struct trh_hdr *trh);
static void rif_check_expire(unsigned long dummy);
 
typedef struct rif_cache_s *rif_cache;
 
struct rif_cache_s {	
	 unsigned char addr[TR_ALEN];
	 unsigned short rcf;
	 unsigned short rseg[8];
	 rif_cache next;
	 unsigned long last_used;
};
 
#define RIF_TABLE_SIZE 16
rif_cache rif_table[RIF_TABLE_SIZE]={ NULL, };
 
#define RIF_TIMEOUT 60*10*HZ
#define RIF_CHECK_INTERVAL 60*HZ
static struct timer_list rif_timer={ NULL,NULL,RIF_CHECK_INTERVAL,0L,rif_check_expire };
 
int tr_header(struct sk_buff *skb, struct device *dev, unsigned short type,
              void *daddr, void *saddr, unsigned len) 
{
 
	struct trh_hdr *trh=(struct trh_hdr *)skb_push(skb,dev->hard_header_len);
	struct trllc *trllc=(struct trllc *)(trh+1);
 
	trh->ac=AC;
	trh->fc=LLC_FRAME;
 
	if(saddr)
		memcpy(trh->saddr,saddr,dev->addr_len);
	else
		memset(trh->saddr,0,dev->addr_len); /* Adapter fills in address */
 
	trllc->dsap=trllc->ssap=EXTENDED_SAP;
	trllc->llc=UI_CMD;
 
	trllc->protid[0]=trllc->protid[1]=trllc->protid[2]=0x00;
	trllc->ethertype=htons(type);
 
	if(daddr) {
		memcpy(trh->daddr,daddr,dev->addr_len);
		tr_source_route(trh,dev);
		return(dev->hard_header_len);
	}
	return -dev->hard_header_len;
 
}
 
int tr_rebuild_header(void *buff, struct device *dev, unsigned long dest,
							 struct sk_buff *skb) {
 
	struct trh_hdr *trh=(struct trh_hdr *)buff;
	struct trllc *trllc=(struct trllc *)(buff+sizeof(struct trh_hdr));
 
	if(trllc->ethertype != htons(ETH_P_IP)) {
		printk("tr_rebuild_header: Don't know how to resolve type %04X addresses ?\n",(unsigned int)htons(	trllc->ethertype));
		return 0;
	}
 
	if(arp_find(trh->daddr, dest, dev, dev->pa_addr, skb)) {
			return 1;
	}
	else {	
		tr_source_route(trh,dev); 
		return 0;
	}
}
 
unsigned short tr_type_trans(struct sk_buff *skb, struct device *dev) {
 
	struct trh_hdr *trh=(struct trh_hdr *)skb->data;
	struct trllc *trllc=(struct trllc *)(skb->data+sizeof(struct trh_hdr));
 
	skb->mac.raw = skb->data;
 
	skb_pull(skb,dev->hard_header_len);
 
	if(trh->saddr[0] & TR_RII)
		tr_add_rif_info(trh);
 
	if(*trh->daddr & 1) 
	{
		if(!memcmp(trh->daddr,dev->broadcast,TR_ALEN)) 	
			skb->pkt_type=PACKET_BROADCAST;
		else
			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;
	}
 
 	return trllc->ethertype;
}
 
/* We try to do source routing... */
 
static void tr_source_route(struct trh_hdr *trh,struct device *dev) {
 
	int i;
	unsigned int hash;
	rif_cache entry;
 
	/* Broadcasts are single route as stated in RFC 1042 */
	if(!memcmp(&(trh->daddr[0]),&(dev->broadcast[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 {
		for(i=0,hash=0;i<TR_ALEN;hash+=trh->daddr[i++]);
		hash&=RIF_TABLE_SIZE-1;
		for(entry=rif_table[hash];entry && memcmp(&(entry->addr[0]),&(trh->daddr[0]),TR_ALEN);entry=entry->next);
 
		if(entry) {
#if 0
printk("source routing for %02X %02X %02X %02X %02X %02X\n",trh->daddr[0],
		  trh->daddr[1],trh->daddr[2],trh->daddr[3],trh->daddr[4],trh->daddr[5]);
#endif
			if((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;
				entry->last_used=jiffies;
			}
		}
		else {
			trh->rcf=htons((((sizeof(trh->rcf)) << 8) & TR_RCF_LEN_MASK)  
				       | TR_RCF_FRAME2K | TR_RCF_LIMITED_BROADCAST);
			trh->saddr[0]|=TR_RII;
		}
	}
 
}
 
static void tr_add_rif_info(struct trh_hdr *trh) {
 
	int i;
	unsigned int hash;
	rif_cache entry;
 
 
	trh->saddr[0]&=0x7f;
	for(i=0,hash=0;i<TR_ALEN;hash+=trh->saddr[i++]);
	hash&=RIF_TABLE_SIZE-1;
#if 0
	printk("hash: %d\n",hash);
#endif
	for(entry=rif_table[hash];entry && memcmp(&(entry->addr[0]),&(trh->saddr[0]),TR_ALEN);entry=entry->next);
 
	if(entry==NULL) {
#if 0
printk("adding rif_entry: addr:%02X:%02X:%02X:%02X:%02X:%02X rcf:%04X\n",
		trh->saddr[0],trh->saddr[1],trh->saddr[2],
       		trh->saddr[3],trh->saddr[4],trh->saddr[5],
		trh->rcf);
#endif
		entry=kmalloc(sizeof(struct rif_cache_s),GFP_ATOMIC);
		if(!entry) {
			printk("tr.c: Couldn't malloc rif cache entry !\n");
			return;
		}
		entry->rcf=trh->rcf;
		memcpy(&(entry->rseg[0]),&(trh->rseg[0]),8*sizeof(unsigned short));
		memcpy(&(entry->addr[0]),&(trh->saddr[0]),TR_ALEN);
		entry->next=rif_table[hash];
		entry->last_used=jiffies;
		rif_table[hash]=entry;
	}
/* Y. Tahara added */
   else {                                       
		if ( entry->rcf != trh->rcf ) {               
				if (!(trh->rcf & htons(TR_RCF_BROADCAST_MASK))) {
#if 0
printk("updating rif_entry: addr:%02X:%02X:%02X:%02X:%02X:%02X rcf:%04X\n",
		trh->saddr[0],trh->saddr[1],trh->saddr[2],
		trh->saddr[3],trh->saddr[4],trh->saddr[5],
		trh->rcf);
#endif
     		       entry->rcf = trh->rcf;                  
        		    memcpy(&(entry->rseg[0]),&(trh->rseg[0]),8*sizeof(unsigned short));
           		 entry->last_used=jiffies;               
				}                                          
		}                                             
	}
 
}
 
static void rif_check_expire(unsigned long dummy) {
 
	int i;
	unsigned long now=jiffies,flags;
 
	save_flags(flags);
	cli();
 
	for(i=0; i < RIF_TABLE_SIZE;i++) {
 
	rif_cache entry, *pentry=rif_table+i;	
 
		while((entry=*pentry)) 
			if((now-entry->last_used) > RIF_TIMEOUT) {
				*pentry=entry->next;
				kfree_s(entry,sizeof(struct rif_cache_s));
			}
			else
				pentry=&entry->next;	
	}
	restore_flags(flags);
 
	del_timer(&rif_timer);
	rif_timer.expires=jiffies+RIF_CHECK_INTERVAL;
	add_timer(&rif_timer);
 
}
 
int rif_get_info(char *buffer,char **start, off_t offset, int length) {
 
   int len=0;
   off_t begin=0;
   off_t pos=0;
   int size,i;
 
   rif_cache entry;
 
	size=sprintf(buffer,
"   TR address     rcf             routing segments             TTL\n\n");
   pos+=size;
   len+=size;
 
	for(i=0;i < RIF_TABLE_SIZE;i++) {
		for(entry=rif_table[i];entry;entry=entry->next) {
			size=sprintf(buffer+len,"%02X:%02X:%02X:%02X:%02X:%02X %04X %04X %04X %04X %04X %04X %04X %04X %04X %lu\n",
								entry->addr[0],entry->addr[1],entry->addr[2],entry->addr[3],entry->addr[4],entry->addr[5],
								entry->rcf,entry->rseg[0],entry->rseg[1],entry->rseg[2],entry->rseg[3],
								entry->rseg[4],entry->rseg[5],entry->rseg[6],entry->rseg[7],jiffies-entry->last_used); 
			len+=size;
			pos=begin+len;
 
			if(pos<offset) {
				len=0;
				begin=pos;
			}
			if(pos>offset+length)
				break;
   	}
		if(pos>offset+length)
			break;
	}
 
   *start=buffer+(offset-begin); /* Start of wanted data */
   len-=(offset-begin);    /* Start slop */
   if(len>length)
      len=length;    /* Ending slop */
   return len;
}
 
void rif_init(struct net_proto *unused) {
 
	add_timer(&rif_timer);
 
}