296 lines
6.8 KiB
C
296 lines
6.8 KiB
C
/*
|
|
* Implements the IPX routing routines.
|
|
* Code moved from af_ipx.c.
|
|
*
|
|
* Arnaldo Carvalho de Melo <acme@conectiva.com.br>, 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;
|
|
}
|