[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / net / appletalk / ipddp.c

/*
 *	ipddp.c: IP to Appletalk-IP Encapsulation driver for Linux
 *		 Appletalk-IP to IP Decapsulation driver for Linux
 *
 *	Authors:
 *      - DDP-IP Encap by: Bradford W. Johnson <johns393@maroon.tc.umn.edu>
 *	- DDP-IP Decap by: Jay Schulist <jschlst@samba.org>
 *
 *	Derived from:
 *	- Almost all code already existed in net/appletalk/ddp.c I just
 *	  moved/reorginized it into a driver file. Original IP-over-DDP code
 *	  was done by Bradford W. Johnson <johns393@maroon.tc.umn.edu>
 *      - skeleton.c: A network driver outline for linux.
 *        Written 1993-94 by Donald Becker.
 *	- dummy.c: A dummy net driver. By Nick Holloway.
 *	- MacGate: A user space Daemon for Appletalk-IP Decap for
 *	  Linux by Jay Schulist <jschlst@samba.org>
 *
 *      Copyright 1993 United States Government as represented by the
 *      Director, National Security Agency.
 *
 *      This software may be used and distributed according to the terms
 *      of the GNU General Public License, incorporated herein by reference.
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/ip.h>
#include <linux/atalk.h>
#include <linux/if_arp.h>
#include <linux/slab.h>
#include <net/route.h>
#include <asm/uaccess.h>

#include "ipddp.h"		/* Our stuff */

static const char version[] = KERN_INFO "ipddp.c:v0.01 8/28/97 Bradford W. Johnson <johns393@maroon.tc.umn.edu>\n";

static struct ipddp_route *ipddp_route_list;
static DEFINE_SPINLOCK(ipddp_route_lock);

#ifdef CONFIG_IPDDP_ENCAP
static int ipddp_mode = IPDDP_ENCAP;
#else
static int ipddp_mode = IPDDP_DECAP;
#endif

/* Index to functions, as function prototypes. */
static netdev_tx_t ipddp_xmit(struct sk_buff *skb,
				    struct net_device *dev);
static int ipddp_create(struct ipddp_route *new_rt);
static int ipddp_delete(struct ipddp_route *rt);
static struct ipddp_route* __ipddp_find_route(struct ipddp_route *rt);
static int ipddp_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);

static const struct net_device_ops ipddp_netdev_ops = {
	.ndo_start_xmit		= ipddp_xmit,
	.ndo_do_ioctl   	= ipddp_ioctl,
	.ndo_change_mtu		= eth_change_mtu,
	.ndo_set_mac_address 	= eth_mac_addr,
	.ndo_validate_addr	= eth_validate_addr,
};

static struct net_device * __init ipddp_init(void)
{
	static unsigned version_printed;
	struct net_device *dev;
	int err;

	dev = alloc_etherdev(0);
	if (!dev)
		return ERR_PTR(-ENOMEM);

	dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
	strcpy(dev->name, "ipddp%d");

	if (version_printed++ == 0)
                printk(version);

	/* Initialize the device structure. */
	dev->netdev_ops = &ipddp_netdev_ops;

        dev->type = ARPHRD_IPDDP;       	/* IP over DDP tunnel */
        dev->mtu = 585;
        dev->flags |= IFF_NOARP;

        /*
         *      The worst case header we will need is currently a
         *      ethernet header (14 bytes) and a ddp header (sizeof ddpehdr+1)
         *      We send over SNAP so that takes another 8 bytes.
         */
        dev->hard_header_len = 14+8+sizeof(struct ddpehdr)+1;

	err = register_netdev(dev);
	if (err) {
		free_netdev(dev);
		return ERR_PTR(err);
	}

	/* Let the user now what mode we are in */
	if(ipddp_mode == IPDDP_ENCAP)
		printk("%s: Appletalk-IP Encap. mode by Bradford W. Johnson <johns393@maroon.tc.umn.edu>\n", 
			dev->name);
	if(ipddp_mode == IPDDP_DECAP)
		printk("%s: Appletalk-IP Decap. mode by Jay Schulist <jschlst@samba.org>\n", 
			dev->name);

        return dev;
}


/*
 * Transmit LLAP/ELAP frame using aarp_send_ddp.
 */
static netdev_tx_t ipddp_xmit(struct sk_buff *skb, struct net_device *dev)
{
	__be32 paddr = skb_rtable(skb)->rt_gateway;
        struct ddpehdr *ddp;
        struct ipddp_route *rt;
        struct atalk_addr *our_addr;

	spin_lock(&ipddp_route_lock);

	/*
         * Find appropriate route to use, based only on IP number.
         */
        for(rt = ipddp_route_list; rt != NULL; rt = rt->next)
        {
                if(rt->ip == paddr)
                        break;
        }
        if(rt == NULL) {
		spin_unlock(&ipddp_route_lock);
                return NETDEV_TX_OK;
	}

        our_addr = atalk_find_dev_addr(rt->dev);

	if(ipddp_mode == IPDDP_DECAP)
		/* 
		 * Pull off the excess room that should not be there.
		 * This is due to a hard-header problem. This is the
		 * quick fix for now though, till it breaks.
		 */
		skb_pull(skb, 35-(sizeof(struct ddpehdr)+1));

	/* Create the Extended DDP header */
	ddp = (struct ddpehdr *)skb->data;
        ddp->deh_len_hops = htons(skb->len + (1<<10));
        ddp->deh_sum = 0;

	/*
         * For Localtalk we need aarp_send_ddp to strip the
         * long DDP header and place a shot DDP header on it.
         */
        if(rt->dev->type == ARPHRD_LOCALTLK)
        {
                ddp->deh_dnet  = 0;   /* FIXME more hops?? */
                ddp->deh_snet  = 0;
        }
        else
        {
                ddp->deh_dnet  = rt->at.s_net;   /* FIXME more hops?? */
                ddp->deh_snet  = our_addr->s_net;
        }
        ddp->deh_dnode = rt->at.s_node;
        ddp->deh_snode = our_addr->s_node;
        ddp->deh_dport = 72;
        ddp->deh_sport = 72;

        *((__u8 *)(ddp+1)) = 22;        	/* ddp type = IP */

        skb->protocol = htons(ETH_P_ATALK);     /* Protocol has changed */

	dev->stats.tx_packets++;
	dev->stats.tx_bytes += skb->len;

	aarp_send_ddp(rt->dev, skb, &rt->at, NULL);

	spin_unlock(&ipddp_route_lock);

        return NETDEV_TX_OK;
}

/*
 * Create a routing entry. We first verify that the
 * record does not already exist. If it does we return -EEXIST
 */
static int ipddp_create(struct ipddp_route *new_rt)
{
        struct ipddp_route *rt = kmalloc(sizeof(*rt), GFP_KERNEL);

        if (rt == NULL)
                return -ENOMEM;

        rt->ip = new_rt->ip;
        rt->at = new_rt->at;
        rt->next = NULL;
        if ((rt->dev = atrtr_get_dev(&rt->at)) == NULL) {
		kfree(rt);
                return -ENETUNREACH;
        }

	spin_lock_bh(&ipddp_route_lock);
	if (__ipddp_find_route(rt)) {
		spin_unlock_bh(&ipddp_route_lock);
		kfree(rt);
		return -EEXIST;
	}

        rt->next = ipddp_route_list;
        ipddp_route_list = rt;

	spin_unlock_bh(&ipddp_route_lock);

        return 0;
}

/*
 * Delete a route, we only delete a FULL match.
 * If route does not exist we return -ENOENT.
 */
static int ipddp_delete(struct ipddp_route *rt)
{
        struct ipddp_route **r = &ipddp_route_list;
        struct ipddp_route *tmp;

	spin_lock_bh(&ipddp_route_lock);
        while((tmp = *r) != NULL)
        {
                if(tmp->ip == rt->ip &&
		   tmp->at.s_net == rt->at.s_net &&
		   tmp->at.s_node == rt->at.s_node)
                {
                        *r = tmp->next;
			spin_unlock_bh(&ipddp_route_lock);
                        kfree(tmp);
                        return 0;
                }
                r = &tmp->next;
        }

	spin_unlock_bh(&ipddp_route_lock);
        return -ENOENT;
}

/*
 * Find a routing entry, we only return a FULL match
 */
static struct ipddp_route* __ipddp_find_route(struct ipddp_route *rt)
{
        struct ipddp_route *f;

        for(f = ipddp_route_list; f != NULL; f = f->next)
        {
                if(f->ip == rt->ip &&
		   f->at.s_net == rt->at.s_net &&
		   f->at.s_node == rt->at.s_node)
                        return f;
        }

        return NULL;
}

static int ipddp_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
{
        struct ipddp_route __user *rt = ifr->ifr_data;
        struct ipddp_route rcp, rcp2, *rp;

        if(!capable(CAP_NET_ADMIN))
                return -EPERM;

	if(copy_from_user(&rcp, rt, sizeof(rcp)))
		return -EFAULT;

        switch(cmd)
        {
		case SIOCADDIPDDPRT:
                        return ipddp_create(&rcp);

                case SIOCFINDIPDDPRT:
			spin_lock_bh(&ipddp_route_lock);
			rp = __ipddp_find_route(&rcp);
			if (rp)
				memcpy(&rcp2, rp, sizeof(rcp2));
			spin_unlock_bh(&ipddp_route_lock);

			if (rp) {
				if (copy_to_user(rt, &rcp2,
						 sizeof(struct ipddp_route)))
					return -EFAULT;
				return 0;
			} else
				return -ENOENT;

                case SIOCDELIPDDPRT:
                        return ipddp_delete(&rcp);

                default:
                        return -EINVAL;
        }
}

static struct net_device *dev_ipddp;

MODULE_LICENSE("GPL");
module_param(ipddp_mode, int, 0);

static int __init ipddp_init_module(void)
{
	dev_ipddp = ipddp_init();
        if (IS_ERR(dev_ipddp))
                return PTR_ERR(dev_ipddp);
	return 0;
}

static void __exit ipddp_cleanup_module(void)
{
        struct ipddp_route *p;

	unregister_netdev(dev_ipddp);
        free_netdev(dev_ipddp);

        while (ipddp_route_list) {
                p = ipddp_route_list->next;
                kfree(ipddp_route_list);
                ipddp_route_list = p;
        }
}

module_init(ipddp_init_module);
module_exit(ipddp_cleanup_module);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* ipddp.c: IP to Appletalk-IP Encapsulation driver for Linux
	3	* Appletalk-IP to IP Decapsulation driver for Linux
	4	*
	5	* Authors:
	6	* - DDP-IP Encap by: Bradford W. Johnson <johns393@maroon.tc.umn.edu>
	7	* - DDP-IP Decap by: Jay Schulist <jschlst@samba.org>
	8	*
	9	* Derived from:
	10	* - Almost all code already existed in net/appletalk/ddp.c I just
	11	* moved/reorginized it into a driver file. Original IP-over-DDP code
	12	* was done by Bradford W. Johnson <johns393@maroon.tc.umn.edu>
	13	* - skeleton.c: A network driver outline for linux.
	14	* Written 1993-94 by Donald Becker.
	15	* - dummy.c: A dummy net driver. By Nick Holloway.
	16	* - MacGate: A user space Daemon for Appletalk-IP Decap for
	17	* Linux by Jay Schulist <jschlst@samba.org>
	18	*
	19	* Copyright 1993 United States Government as represented by the
	20	* Director, National Security Agency.
	21	*
	22	* This software may be used and distributed according to the terms
	23	* of the GNU General Public License, incorporated herein by reference.
	24	*/
	25
1da177e4 LT	26	#include <linux/module.h>
	27	#include <linux/kernel.h>
	28	#include <linux/init.h>
	29	#include <linux/netdevice.h>
	30	#include <linux/etherdevice.h>
	31	#include <linux/ip.h>
	32	#include <linux/atalk.h>
	33	#include <linux/if_arp.h>
5a0e3ad6	34	#include <linux/slab.h>
1da177e4 LT	35	#include <net/route.h>
	36	#include <asm/uaccess.h>
	37
	38	#include "ipddp.h" /* Our stuff */
	39
	40	static const char version[] = KERN_INFO "ipddp.c:v0.01 8/28/97 Bradford W. Johnson <johns393@maroon.tc.umn.edu>\n";
	41
	42	static struct ipddp_route *ipddp_route_list;
5615968a	43	static DEFINE_SPINLOCK(ipddp_route_lock);
1da177e4 LT	44
	45	#ifdef CONFIG_IPDDP_ENCAP
	46	static int ipddp_mode = IPDDP_ENCAP;
	47	#else
	48	static int ipddp_mode = IPDDP_DECAP;
	49	#endif
	50
	51	/* Index to functions, as function prototypes. */
0fc48098 SH	52	static netdev_tx_t ipddp_xmit(struct sk_buff *skb,
0fc48098 SH	53	struct net_device *dev);
1da177e4 LT	54	static int ipddp_create(struct ipddp_route *new_rt);
1da177e4 LT	55	static int ipddp_delete(struct ipddp_route *rt);
5615968a	56	static struct ipddp_route* __ipddp_find_route(struct ipddp_route *rt);
1da177e4 LT	57	static int ipddp_ioctl(struct net_device dev, struct ifreq ifr, int cmd);
1da177e4 LT	58
43a67304 SH	59	static const struct net_device_ops ipddp_netdev_ops = {
	60	.ndo_start_xmit = ipddp_xmit,
	61	.ndo_do_ioctl = ipddp_ioctl,
	62	.ndo_change_mtu = eth_change_mtu,
	63	.ndo_set_mac_address = eth_mac_addr,
	64	.ndo_validate_addr = eth_validate_addr,
	65	};
1da177e4 LT	66
	67	static struct net_device * __init ipddp_init(void)
	68	{
	69	static unsigned version_printed;
	70	struct net_device *dev;
	71	int err;
	72
43a67304	73	dev = alloc_etherdev(0);
1da177e4 LT	74	if (!dev)
	75	return ERR_PTR(-ENOMEM);
	76
93f154b5	77	dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
1da177e4 LT	78	strcpy(dev->name, "ipddp%d");
	79
	80	if (version_printed++ == 0)
	81	printk(version);
	82
421f91d2	83	/* Initialize the device structure. */
43a67304	84	dev->netdev_ops = &ipddp_netdev_ops;
1da177e4 LT	85
	86	dev->type = ARPHRD_IPDDP; /* IP over DDP tunnel */
	87	dev->mtu = 585;
	88	dev->flags \|= IFF_NOARP;
	89
	90	/*
	91	* The worst case header we will need is currently a
	92	* ethernet header (14 bytes) and a ddp header (sizeof ddpehdr+1)
	93	* We send over SNAP so that takes another 8 bytes.
	94	*/
	95	dev->hard_header_len = 14+8+sizeof(struct ddpehdr)+1;
	96
	97	err = register_netdev(dev);
	98	if (err) {
	99	free_netdev(dev);
	100	return ERR_PTR(err);
	101	}
	102
	103	/* Let the user now what mode we are in */
	104	if(ipddp_mode == IPDDP_ENCAP)
	105	printk("%s: Appletalk-IP Encap. mode by Bradford W. Johnson <johns393@maroon.tc.umn.edu>\n",
	106	dev->name);
	107	if(ipddp_mode == IPDDP_DECAP)
	108	printk("%s: Appletalk-IP Decap. mode by Jay Schulist <jschlst@samba.org>\n",
	109	dev->name);
	110
	111	return dev;
	112	}
	113
1da177e4 LT	114
	115	/*
	116	* Transmit LLAP/ELAP frame using aarp_send_ddp.
	117	*/
0fc48098	118	static netdev_tx_t ipddp_xmit(struct sk_buff skb, struct net_device dev)
1da177e4	119	{
511c3f92	120	__be32 paddr = skb_rtable(skb)->rt_gateway;
1da177e4 LT	121	struct ddpehdr *ddp;
	122	struct ipddp_route *rt;
	123	struct atalk_addr *our_addr;
	124
5615968a DM	125	spin_lock(&ipddp_route_lock);
5615968a DM	126
1da177e4 LT	127	/*
	128	* Find appropriate route to use, based only on IP number.
	129	*/
	130	for(rt = ipddp_route_list; rt != NULL; rt = rt->next)
	131	{
	132	if(rt->ip == paddr)
	133	break;
	134	}
5615968a DM	135	if(rt == NULL) {
5615968a DM	136	spin_unlock(&ipddp_route_lock);
6ed10654	137	return NETDEV_TX_OK;
5615968a	138	}
1da177e4 LT	139
	140	our_addr = atalk_find_dev_addr(rt->dev);
	141
	142	if(ipddp_mode == IPDDP_DECAP)
	143	/*
	144	* Pull off the excess room that should not be there.
	145	* This is due to a hard-header problem. This is the
	146	* quick fix for now though, till it breaks.
	147	*/
	148	skb_pull(skb, 35-(sizeof(struct ddpehdr)+1));
	149
	150	/* Create the Extended DDP header */
	151	ddp = (struct ddpehdr *)skb->data;
2a50f28c	152	ddp->deh_len_hops = htons(skb->len + (1<<10));
1da177e4 LT	153	ddp->deh_sum = 0;
	154
	155	/*
	156	* For Localtalk we need aarp_send_ddp to strip the
	157	* long DDP header and place a shot DDP header on it.
	158	*/
	159	if(rt->dev->type == ARPHRD_LOCALTLK)
	160	{
	161	ddp->deh_dnet = 0; /* FIXME more hops?? */
	162	ddp->deh_snet = 0;
	163	}
	164	else
	165	{
	166	ddp->deh_dnet = rt->at.s_net; /* FIXME more hops?? */
	167	ddp->deh_snet = our_addr->s_net;
	168	}
	169	ddp->deh_dnode = rt->at.s_node;
	170	ddp->deh_snode = our_addr->s_node;
	171	ddp->deh_dport = 72;
	172	ddp->deh_sport = 72;
	173
	174	((__u8 )(ddp+1)) = 22; /* ddp type = IP */
1da177e4 LT	175
	176	skb->protocol = htons(ETH_P_ATALK); /* Protocol has changed */
	177
43a67304 SH	178	dev->stats.tx_packets++;
43a67304 SH	179	dev->stats.tx_bytes += skb->len;
1da177e4	180
ffcfb8db	181	aarp_send_ddp(rt->dev, skb, &rt->at, NULL);
1da177e4	182
5615968a DM	183	spin_unlock(&ipddp_route_lock);
5615968a DM	184
6ed10654	185	return NETDEV_TX_OK;
1da177e4 LT	186	}
	187
	188	/*
	189	* Create a routing entry. We first verify that the
	190	* record does not already exist. If it does we return -EEXIST
	191	*/
	192	static int ipddp_create(struct ipddp_route *new_rt)
	193	{
5cbded58	194	struct ipddp_route rt = kmalloc(sizeof(rt), GFP_KERNEL);
1da177e4 LT	195
	196	if (rt == NULL)
	197	return -ENOMEM;
	198
	199	rt->ip = new_rt->ip;
	200	rt->at = new_rt->at;
	201	rt->next = NULL;
	202	if ((rt->dev = atrtr_get_dev(&rt->at)) == NULL) {
	203	kfree(rt);
	204	return -ENETUNREACH;
	205	}
	206
5615968a DM	207	spin_lock_bh(&ipddp_route_lock);
	208	if (__ipddp_find_route(rt)) {
	209	spin_unlock_bh(&ipddp_route_lock);
1da177e4 LT	210	kfree(rt);
	211	return -EEXIST;
	212	}
	213
	214	rt->next = ipddp_route_list;
	215	ipddp_route_list = rt;
	216
5615968a DM	217	spin_unlock_bh(&ipddp_route_lock);
5615968a DM	218
1da177e4 LT	219	return 0;
	220	}
	221
	222	/*
	223	* Delete a route, we only delete a FULL match.
	224	* If route does not exist we return -ENOENT.
	225	*/
	226	static int ipddp_delete(struct ipddp_route *rt)
	227	{
	228	struct ipddp_route **r = &ipddp_route_list;
	229	struct ipddp_route *tmp;
	230
5615968a	231	spin_lock_bh(&ipddp_route_lock);
1da177e4 LT	232	while((tmp = *r) != NULL)
1da177e4 LT	233	{
8e95a202 JP	234	if(tmp->ip == rt->ip &&
	235	tmp->at.s_net == rt->at.s_net &&
	236	tmp->at.s_node == rt->at.s_node)
1da177e4 LT	237	{
1da177e4 LT	238	*r = tmp->next;
5615968a	239	spin_unlock_bh(&ipddp_route_lock);
1da177e4 LT	240	kfree(tmp);
	241	return 0;
	242	}
	243	r = &tmp->next;
	244	}
	245
5615968a	246	spin_unlock_bh(&ipddp_route_lock);
807540ba	247	return -ENOENT;
1da177e4 LT	248	}
	249
	250	/*
	251	* Find a routing entry, we only return a FULL match
	252	*/
5615968a	253	static struct ipddp_route* __ipddp_find_route(struct ipddp_route *rt)
1da177e4 LT	254	{
	255	struct ipddp_route *f;
	256
	257	for(f = ipddp_route_list; f != NULL; f = f->next)
	258	{
8e95a202 JP	259	if(f->ip == rt->ip &&
	260	f->at.s_net == rt->at.s_net &&
	261	f->at.s_node == rt->at.s_node)
807540ba	262	return f;
1da177e4 LT	263	}
1da177e4 LT	264
807540ba	265	return NULL;
1da177e4 LT	266	}
	267
	268	static int ipddp_ioctl(struct net_device dev, struct ifreq ifr, int cmd)
	269	{
	270	struct ipddp_route __user *rt = ifr->ifr_data;
5615968a	271	struct ipddp_route rcp, rcp2, *rp;
1da177e4 LT	272
	273	if(!capable(CAP_NET_ADMIN))
	274	return -EPERM;
	275
	276	if(copy_from_user(&rcp, rt, sizeof(rcp)))
	277	return -EFAULT;
	278
	279	switch(cmd)
	280	{
	281	case SIOCADDIPDDPRT:
807540ba	282	return ipddp_create(&rcp);
1da177e4 LT	283
1da177e4 LT	284	case SIOCFINDIPDDPRT:
5615968a DM	285	spin_lock_bh(&ipddp_route_lock);
	286	rp = __ipddp_find_route(&rcp);
	287	if (rp)
	288	memcpy(&rcp2, rp, sizeof(rcp2));
	289	spin_unlock_bh(&ipddp_route_lock);
	290
	291	if (rp) {
	292	if (copy_to_user(rt, &rcp2,
	293	sizeof(struct ipddp_route)))
	294	return -EFAULT;
	295	return 0;
	296	} else
	297	return -ENOENT;
1da177e4 LT	298
1da177e4 LT	299	case SIOCDELIPDDPRT:
807540ba	300	return ipddp_delete(&rcp);
1da177e4 LT	301
	302	default:
	303	return -EINVAL;
	304	}
	305	}
	306
	307	static struct net_device *dev_ipddp;
	308
	309	MODULE_LICENSE("GPL");
	310	module_param(ipddp_mode, int, 0);
	311
	312	static int __init ipddp_init_module(void)
	313	{
	314	dev_ipddp = ipddp_init();
	315	if (IS_ERR(dev_ipddp))
	316	return PTR_ERR(dev_ipddp);
	317	return 0;
	318	}
	319
	320	static void __exit ipddp_cleanup_module(void)
	321	{
	322	struct ipddp_route *p;
	323
	324	unregister_netdev(dev_ipddp);
	325	free_netdev(dev_ipddp);
	326
	327	while (ipddp_route_list) {
	328	p = ipddp_route_list->next;
	329	kfree(ipddp_route_list);
	330	ipddp_route_list = p;
	331	}
	332	}
	333
	334	module_init(ipddp_init_module);
	335	module_exit(ipddp_cleanup_module);