[linux.git] / net / ipx / ipx_route.c

/*
 *	Implements the IPX routing routines.
 *	Code moved from af_ipx.c.
 *
 *	Arnaldo Carvalho de Melo <[email protected]>, 2003
 *
 *	See net/ipx/ChangeLog.
 */

#include <linux/list.h>
#include <linux/route.h>
#include <linux/slab.h>
#include <linux/spinlock.h>

#include <net/ipx.h>
#include <net/sock.h>

LIST_HEAD(ipx_routes);
DEFINE_RWLOCK(ipx_routes_lock);

extern struct ipx_interface *ipx_internal_net;

extern __be16 ipx_cksum(struct ipxhdr *packet, int length);
extern struct ipx_interface *ipxitf_find_using_net(__be32 net);
extern int ipxitf_demux_socket(struct ipx_interface *intrfc,
			       struct sk_buff *skb, int copy);
extern int ipxitf_demux_socket(struct ipx_interface *intrfc,
			       struct sk_buff *skb, int copy);
extern int ipxitf_send(struct ipx_interface *intrfc, struct sk_buff *skb,
		       char *node);
extern struct ipx_interface *ipxitf_find_using_net(__be32 net);

struct ipx_route *ipxrtr_lookup(__be32 net)
{
	struct ipx_route *r;

	read_lock_bh(&ipx_routes_lock);
	list_for_each_entry(r, &ipx_routes, node)
		if (r->ir_net == net) {
			ipxrtr_hold(r);
			goto unlock;
		}
	r = NULL;
unlock:
	read_unlock_bh(&ipx_routes_lock);
	return r;
}

/*
 * Caller must hold a reference to intrfc
 */
int ipxrtr_add_route(__be32 network, struct ipx_interface *intrfc,
		     unsigned char *node)
{
	struct ipx_route *rt;
	int rc;

	/* Get a route structure; either existing or create */
	rt = ipxrtr_lookup(network);
	if (!rt) {
		rt = kmalloc(sizeof(*rt), GFP_ATOMIC);
		rc = -EAGAIN;
		if (!rt)
			goto out;

		atomic_set(&rt->refcnt, 1);
		ipxrtr_hold(rt);
		write_lock_bh(&ipx_routes_lock);
		list_add(&rt->node, &ipx_routes);
		write_unlock_bh(&ipx_routes_lock);
	} else {
		rc = -EEXIST;
		if (intrfc == ipx_internal_net)
			goto out_put;
	}

	rt->ir_net 	= network;
	rt->ir_intrfc 	= intrfc;
	if (!node) {
		memset(rt->ir_router_node, '\0', IPX_NODE_LEN);
		rt->ir_routed = 0;
	} else {
		memcpy(rt->ir_router_node, node, IPX_NODE_LEN);
		rt->ir_routed = 1;
	}

	rc = 0;
out_put:
	ipxrtr_put(rt);
out:
	return rc;
}

void ipxrtr_del_routes(struct ipx_interface *intrfc)
{
	struct ipx_route *r, *tmp;

	write_lock_bh(&ipx_routes_lock);
	list_for_each_entry_safe(r, tmp, &ipx_routes, node)
		if (r->ir_intrfc == intrfc) {
			list_del(&r->node);
			ipxrtr_put(r);
		}
	write_unlock_bh(&ipx_routes_lock);
}

static int ipxrtr_create(struct ipx_route_definition *rd)
{
	struct ipx_interface *intrfc;
	int rc = -ENETUNREACH;

	/* Find the appropriate interface */
	intrfc = ipxitf_find_using_net(rd->ipx_router_network);
	if (!intrfc)
		goto out;
	rc = ipxrtr_add_route(rd->ipx_network, intrfc, rd->ipx_router_node);
	ipxitf_put(intrfc);
out:
	return rc;
}

static int ipxrtr_delete(__be32 net)
{
	struct ipx_route *r, *tmp;
	int rc;

	write_lock_bh(&ipx_routes_lock);
	list_for_each_entry_safe(r, tmp, &ipx_routes, node)
		if (r->ir_net == net) {
			/* Directly connected; can't lose route */
			rc = -EPERM;
			if (!r->ir_routed)
				goto out;
			list_del(&r->node);
			ipxrtr_put(r);
			rc = 0;
			goto out;
		}
	rc = -ENOENT;
out:
	write_unlock_bh(&ipx_routes_lock);
	return rc;
}

/*
 * The skb has to be unshared, we'll end up calling ipxitf_send, that'll
 * modify the packet
 */
int ipxrtr_route_skb(struct sk_buff *skb)
{
	struct ipxhdr *ipx = ipx_hdr(skb);
	struct ipx_route *r = ipxrtr_lookup(IPX_SKB_CB(skb)->ipx_dest_net);

	if (!r) {	/* no known route */
		kfree_skb(skb);
		return 0;
	}

	ipxitf_hold(r->ir_intrfc);
	ipxitf_send(r->ir_intrfc, skb, r->ir_routed ?
			r->ir_router_node : ipx->ipx_dest.node);
	ipxitf_put(r->ir_intrfc);
	ipxrtr_put(r);

	return 0;
}

/*
 * Route an outgoing frame from a socket.
 */
int ipxrtr_route_packet(struct sock *sk, struct sockaddr_ipx *usipx,
			struct iovec *iov, size_t len, int noblock)
{
	struct sk_buff *skb;
	struct ipx_sock *ipxs = ipx_sk(sk);
	struct ipx_interface *intrfc;
	struct ipxhdr *ipx;
	size_t size;
	int ipx_offset;
	struct ipx_route *rt = NULL;
	int rc;

	/* Find the appropriate interface on which to send packet */
	if (!usipx->sipx_network && ipx_primary_net) {
		usipx->sipx_network = ipx_primary_net->if_netnum;
		intrfc = ipx_primary_net;
	} else {
		rt = ipxrtr_lookup(usipx->sipx_network);
		rc = -ENETUNREACH;
		if (!rt)
			goto out;
		intrfc = rt->ir_intrfc;
	}

	ipxitf_hold(intrfc);
	ipx_offset = intrfc->if_ipx_offset;
	size = sizeof(struct ipxhdr) + len + ipx_offset;

	skb = sock_alloc_send_skb(sk, size, noblock, &rc);
	if (!skb)
		goto out_put;

	skb_reserve(skb, ipx_offset);
	skb->sk = sk;

	/* Fill in IPX header */
	skb_reset_network_header(skb);
	skb_reset_transport_header(skb);
	skb_put(skb, sizeof(struct ipxhdr));
	ipx = ipx_hdr(skb);
	ipx->ipx_pktsize = htons(len + sizeof(struct ipxhdr));
	IPX_SKB_CB(skb)->ipx_tctrl = 0;
	ipx->ipx_type 	 = usipx->sipx_type;

	IPX_SKB_CB(skb)->last_hop.index = -1;
#ifdef CONFIG_IPX_INTERN
	IPX_SKB_CB(skb)->ipx_source_net = ipxs->intrfc->if_netnum;
	memcpy(ipx->ipx_source.node, ipxs->node, IPX_NODE_LEN);
#else
	rc = ntohs(ipxs->port);
	if (rc == 0x453 || rc == 0x452) {
		/* RIP/SAP special handling for mars_nwe */
		IPX_SKB_CB(skb)->ipx_source_net = intrfc->if_netnum;
		memcpy(ipx->ipx_source.node, intrfc->if_node, IPX_NODE_LEN);
	} else {
		IPX_SKB_CB(skb)->ipx_source_net = ipxs->intrfc->if_netnum;
		memcpy(ipx->ipx_source.node, ipxs->intrfc->if_node,
			IPX_NODE_LEN);
	}
#endif	/* CONFIG_IPX_INTERN */
	ipx->ipx_source.sock		= ipxs->port;
	IPX_SKB_CB(skb)->ipx_dest_net	= usipx->sipx_network;
	memcpy(ipx->ipx_dest.node, usipx->sipx_node, IPX_NODE_LEN);
	ipx->ipx_dest.sock		= usipx->sipx_port;

	rc = memcpy_fromiovec(skb_put(skb, len), iov, len);
	if (rc) {
		kfree_skb(skb);
		goto out_put;
	}

	/* Apply checksum. Not allowed on 802.3 links. */
	if (sk->sk_no_check || intrfc->if_dlink_type == htons(IPX_FRAME_8023))
		ipx->ipx_checksum = htons(0xFFFF);
	else
		ipx->ipx_checksum = ipx_cksum(ipx, len + sizeof(struct ipxhdr));

	rc = ipxitf_send(intrfc, skb, (rt && rt->ir_routed) ?
			 rt->ir_router_node : ipx->ipx_dest.node);
out_put:
	ipxitf_put(intrfc);
	if (rt)
		ipxrtr_put(rt);
out:
	return rc;
}

/*
 * We use a normal struct rtentry for route handling
 */
int ipxrtr_ioctl(unsigned int cmd, void __user *arg)
{
	struct rtentry rt;	/* Use these to behave like 'other' stacks */
	struct sockaddr_ipx *sg, *st;
	int rc = -EFAULT;

	if (copy_from_user(&rt, arg, sizeof(rt)))
		goto out;

	sg = (struct sockaddr_ipx *)&rt.rt_gateway;
	st = (struct sockaddr_ipx *)&rt.rt_dst;

	rc = -EINVAL;
	if (!(rt.rt_flags & RTF_GATEWAY) || /* Direct routes are fixed */
	    sg->sipx_family != AF_IPX ||
	    st->sipx_family != AF_IPX)
		goto out;

	switch (cmd) {
	case SIOCDELRT:
		rc = ipxrtr_delete(st->sipx_network);
		break;
	case SIOCADDRT: {
		struct ipx_route_definition f;
		f.ipx_network		= st->sipx_network;
		f.ipx_router_network	= sg->sipx_network;
		memcpy(f.ipx_router_node, sg->sipx_node, IPX_NODE_LEN);
		rc = ipxrtr_create(&f);
		break;
	}
	}

out:
	return rc;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Implements the IPX routing routines.
	3	* Code moved from af_ipx.c.
	4	*
	5	* Arnaldo Carvalho de Melo <[email protected]>, 2003
	6	*
	7	* See net/ipx/ChangeLog.
	8	*/
	9
1da177e4 LT	10	#include <linux/list.h>
1da177e4 LT	11	#include <linux/route.h>
5a0e3ad6	12	#include <linux/slab.h>
1da177e4 LT	13	#include <linux/spinlock.h>
	14
	15	#include <net/ipx.h>
	16	#include <net/sock.h>
	17
	18	LIST_HEAD(ipx_routes);
	19	DEFINE_RWLOCK(ipx_routes_lock);
	20
	21	extern struct ipx_interface *ipx_internal_net;
	22
02e60370	23	extern __be16 ipx_cksum(struct ipxhdr *packet, int length);
4833ed09	24	extern struct ipx_interface *ipxitf_find_using_net(__be32 net);
1da177e4 LT	25	extern int ipxitf_demux_socket(struct ipx_interface *intrfc,
	26	struct sk_buff *skb, int copy);
	27	extern int ipxitf_demux_socket(struct ipx_interface *intrfc,
	28	struct sk_buff *skb, int copy);
	29	extern int ipxitf_send(struct ipx_interface intrfc, struct sk_buff skb,
	30	char *node);
4833ed09	31	extern struct ipx_interface *ipxitf_find_using_net(__be32 net);
1da177e4	32
4833ed09	33	struct ipx_route *ipxrtr_lookup(__be32 net)
1da177e4 LT	34	{
	35	struct ipx_route *r;
	36
	37	read_lock_bh(&ipx_routes_lock);
	38	list_for_each_entry(r, &ipx_routes, node)
	39	if (r->ir_net == net) {
	40	ipxrtr_hold(r);
	41	goto unlock;
	42	}
	43	r = NULL;
	44	unlock:
	45	read_unlock_bh(&ipx_routes_lock);
	46	return r;
	47	}
	48
	49	/*
	50	* Caller must hold a reference to intrfc
	51	*/
4833ed09	52	int ipxrtr_add_route(__be32 network, struct ipx_interface *intrfc,
1da177e4 LT	53	unsigned char *node)
	54	{
	55	struct ipx_route *rt;
	56	int rc;
	57
	58	/* Get a route structure; either existing or create */
	59	rt = ipxrtr_lookup(network);
	60	if (!rt) {
	61	rt = kmalloc(sizeof(*rt), GFP_ATOMIC);
	62	rc = -EAGAIN;
	63	if (!rt)
	64	goto out;
	65
	66	atomic_set(&rt->refcnt, 1);
	67	ipxrtr_hold(rt);
	68	write_lock_bh(&ipx_routes_lock);
	69	list_add(&rt->node, &ipx_routes);
	70	write_unlock_bh(&ipx_routes_lock);
	71	} else {
	72	rc = -EEXIST;
	73	if (intrfc == ipx_internal_net)
	74	goto out_put;
	75	}
	76
	77	rt->ir_net = network;
	78	rt->ir_intrfc = intrfc;
	79	if (!node) {
	80	memset(rt->ir_router_node, '\0', IPX_NODE_LEN);
	81	rt->ir_routed = 0;
	82	} else {
	83	memcpy(rt->ir_router_node, node, IPX_NODE_LEN);
	84	rt->ir_routed = 1;
	85	}
	86
	87	rc = 0;
	88	out_put:
	89	ipxrtr_put(rt);
	90	out:
	91	return rc;
	92	}
	93
	94	void ipxrtr_del_routes(struct ipx_interface *intrfc)
	95	{
	96	struct ipx_route r, tmp;
	97
	98	write_lock_bh(&ipx_routes_lock);
	99	list_for_each_entry_safe(r, tmp, &ipx_routes, node)
	100	if (r->ir_intrfc == intrfc) {
	101	list_del(&r->node);
	102	ipxrtr_put(r);
	103	}
	104	write_unlock_bh(&ipx_routes_lock);
	105	}
	106
	107	static int ipxrtr_create(struct ipx_route_definition *rd)
	108	{
	109	struct ipx_interface *intrfc;
	110	int rc = -ENETUNREACH;
	111
	112	/* Find the appropriate interface */
	113	intrfc = ipxitf_find_using_net(rd->ipx_router_network);
	114	if (!intrfc)
	115	goto out;
	116	rc = ipxrtr_add_route(rd->ipx_network, intrfc, rd->ipx_router_node);
117	ipxitf_put(intrfc);
118	out:
119	return rc;
120	}
121
4833ed09	122	static int ipxrtr_delete(__be32 net)
1da177e4 LT	123	{
	124	struct ipx_route r, tmp;
	125	int rc;
	126
	127	write_lock_bh(&ipx_routes_lock);
	128	list_for_each_entry_safe(r, tmp, &ipx_routes, node)
	129	if (r->ir_net == net) {
	130	/* Directly connected; can't lose route */
	131	rc = -EPERM;
	132	if (!r->ir_routed)
	133	goto out;
	134	list_del(&r->node);
	135	ipxrtr_put(r);
	136	rc = 0;
	137	goto out;
	138	}
	139	rc = -ENOENT;
	140	out:
	141	write_unlock_bh(&ipx_routes_lock);
	142	return rc;
	143	}
	144
	145	/*
	146	* The skb has to be unshared, we'll end up calling ipxitf_send, that'll
	147	* modify the packet
	148	*/
	149	int ipxrtr_route_skb(struct sk_buff *skb)
	150	{
	151	struct ipxhdr *ipx = ipx_hdr(skb);
	152	struct ipx_route *r = ipxrtr_lookup(IPX_SKB_CB(skb)->ipx_dest_net);
	153
	154	if (!r) { /* no known route */
	155	kfree_skb(skb);
	156	return 0;
	157	}
	158
	159	ipxitf_hold(r->ir_intrfc);
	160	ipxitf_send(r->ir_intrfc, skb, r->ir_routed ?
	161	r->ir_router_node : ipx->ipx_dest.node);
	162	ipxitf_put(r->ir_intrfc);
	163	ipxrtr_put(r);
	164
	165	return 0;
	166	}
	167
	168	/*
	169	* Route an outgoing frame from a socket.
	170	*/
	171	int ipxrtr_route_packet(struct sock sk, struct sockaddr_ipx usipx,
	172	struct iovec *iov, size_t len, int noblock)
	173	{
	174	struct sk_buff *skb;
	175	struct ipx_sock *ipxs = ipx_sk(sk);
	176	struct ipx_interface *intrfc;
	177	struct ipxhdr *ipx;
	178	size_t size;
	179	int ipx_offset;
	180	struct ipx_route *rt = NULL;
	181	int rc;
	182
	183	/* Find the appropriate interface on which to send packet */
	184	if (!usipx->sipx_network && ipx_primary_net) {
	185	usipx->sipx_network = ipx_primary_net->if_netnum;
	186	intrfc = ipx_primary_net;
187	} else {
188	rt = ipxrtr_lookup(usipx->sipx_network);
189	rc = -ENETUNREACH;
190	if (!rt)
191	goto out;
192	intrfc = rt->ir_intrfc;
193	}
194
195	ipxitf_hold(intrfc);
196	ipx_offset = intrfc->if_ipx_offset;
197	size = sizeof(struct ipxhdr) + len + ipx_offset;
198
199	skb = sock_alloc_send_skb(sk, size, noblock, &rc);
200	if (!skb)
201	goto out_put;
202
203	skb_reserve(skb, ipx_offset);
204	skb->sk = sk;
205
206	/* Fill in IPX header */
7e28ecc2	207	skb_reset_network_header(skb);
badff6d0	208	skb_reset_transport_header(skb);
7e28ecc2	209	skb_put(skb, sizeof(struct ipxhdr));
1da177e4 LT	210	ipx = ipx_hdr(skb);
	211	ipx->ipx_pktsize = htons(len + sizeof(struct ipxhdr));
	212	IPX_SKB_CB(skb)->ipx_tctrl = 0;
	213	ipx->ipx_type = usipx->sipx_type;
	214
	215	IPX_SKB_CB(skb)->last_hop.index = -1;
	216	#ifdef CONFIG_IPX_INTERN
	217	IPX_SKB_CB(skb)->ipx_source_net = ipxs->intrfc->if_netnum;
	218	memcpy(ipx->ipx_source.node, ipxs->node, IPX_NODE_LEN);
	219	#else
	220	rc = ntohs(ipxs->port);
	221	if (rc == 0x453 \|\| rc == 0x452) {
	222	/* RIP/SAP special handling for mars_nwe */
	223	IPX_SKB_CB(skb)->ipx_source_net = intrfc->if_netnum;
	224	memcpy(ipx->ipx_source.node, intrfc->if_node, IPX_NODE_LEN);
	225	} else {
	226	IPX_SKB_CB(skb)->ipx_source_net = ipxs->intrfc->if_netnum;
	227	memcpy(ipx->ipx_source.node, ipxs->intrfc->if_node,
	228	IPX_NODE_LEN);
	229	}
	230	#endif /* CONFIG_IPX_INTERN */
	231	ipx->ipx_source.sock = ipxs->port;
	232	IPX_SKB_CB(skb)->ipx_dest_net = usipx->sipx_network;
	233	memcpy(ipx->ipx_dest.node, usipx->sipx_node, IPX_NODE_LEN);
	234	ipx->ipx_dest.sock = usipx->sipx_port;
	235
	236	rc = memcpy_fromiovec(skb_put(skb, len), iov, len);
	237	if (rc) {
	238	kfree_skb(skb);
	239	goto out_put;
981c0ff6	240	}
1da177e4 LT	241
1da177e4 LT	242	/* Apply checksum. Not allowed on 802.3 links. */
f8d59621	243	if (sk->sk_no_check \|\| intrfc->if_dlink_type == htons(IPX_FRAME_8023))
02e60370	244	ipx->ipx_checksum = htons(0xFFFF);
1da177e4 LT	245	else
	246	ipx->ipx_checksum = ipx_cksum(ipx, len + sizeof(struct ipxhdr));
	247
981c0ff6	248	rc = ipxitf_send(intrfc, skb, (rt && rt->ir_routed) ?
1da177e4 LT	249	rt->ir_router_node : ipx->ipx_dest.node);
	250	out_put:
	251	ipxitf_put(intrfc);
	252	if (rt)
	253	ipxrtr_put(rt);
	254	out:
	255	return rc;
	256	}
	257
	258	/*
	259	* We use a normal struct rtentry for route handling
	260	*/
	261	int ipxrtr_ioctl(unsigned int cmd, void __user *arg)
	262	{
	263	struct rtentry rt; /* Use these to behave like 'other' stacks */
	264	struct sockaddr_ipx sg, st;
	265	int rc = -EFAULT;
	266
	267	if (copy_from_user(&rt, arg, sizeof(rt)))
	268	goto out;
	269
	270	sg = (struct sockaddr_ipx *)&rt.rt_gateway;
	271	st = (struct sockaddr_ipx *)&rt.rt_dst;
	272
	273	rc = -EINVAL;
	274	if (!(rt.rt_flags & RTF_GATEWAY) \|\| /* Direct routes are fixed */
	275	sg->sipx_family != AF_IPX \|\|
	276	st->sipx_family != AF_IPX)
	277	goto out;
	278
	279	switch (cmd) {
	280	case SIOCDELRT:
	281	rc = ipxrtr_delete(st->sipx_network);
	282	break;
	283	case SIOCADDRT: {
	284	struct ipx_route_definition f;
	285	f.ipx_network = st->sipx_network;
	286	f.ipx_router_network = sg->sipx_network;
	287	memcpy(f.ipx_router_node, sg->sipx_node, IPX_NODE_LEN);
	288	rc = ipxrtr_create(&f);
	289	break;
	290	}
	291	}
	292
	293	out:
	294	return rc;
	295	}