dn_route.c 47.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
/*
 * DECnet       An implementation of the DECnet protocol suite for the LINUX
 *              operating system.  DECnet is implemented using the  BSD Socket
 *              interface as the means of communication with the user level.
 *
 *              DECnet Routing Functions (Endnode and Router)
 *
 * Authors:     Steve Whitehouse <SteveW@ACM.org>
 *              Eduardo Marcelo Serrat <emserrat@geocities.com>
 *
 * Changes:
 *              Steve Whitehouse : Fixes to allow "intra-ethernet" and
 *                                 "return-to-sender" bits on outgoing
 *                                 packets.
 *		Steve Whitehouse : Timeouts for cached routes.
 *              Steve Whitehouse : Use dst cache for input routes too.
 *              Steve Whitehouse : Fixed error values in dn_send_skb.
 *              Steve Whitehouse : Rework routing functions to better fit
 *                                 DECnet routing design
 *              Alexey Kuznetsov : New SMP locking
 *              Steve Whitehouse : More SMP locking changes & dn_cache_dump()
 *              Steve Whitehouse : Prerouting NF hook, now really is prerouting.
 *				   Fixed possible skb leak in rtnetlink funcs.
 *              Steve Whitehouse : Dave Miller's dynamic hash table sizing and
 *                                 Alexey Kuznetsov's finer grained locking
 *                                 from ipv4/route.c.
 *              Steve Whitehouse : Routing is now starting to look like a
 *                                 sensible set of code now, mainly due to
 *                                 my copying the IPv4 routing code. The
 *                                 hooks here are modified and will continue
 *                                 to evolve for a while.
 *              Steve Whitehouse : Real SMP at last :-) Also new netfilter
 *                                 stuff. Look out raw sockets your days
 *                                 are numbered!
 *              Steve Whitehouse : Added return-to-sender functions. Added
 *                                 backlog congestion level return codes.
 *		Steve Whitehouse : Fixed bug where routes were set up with
 *                                 no ref count on net devices.
 *              Steve Whitehouse : RCU for the route cache
 *              Steve Whitehouse : Preparations for the flow cache
 *              Steve Whitehouse : Prepare for nonlinear skbs
 */

/******************************************************************************
    (c) 1995-1998 E.M. Serrat		emserrat@geocities.com
46

Linus Torvalds's avatar
Linus Torvalds committed
47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
    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
    any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
*******************************************************************************/

#include <linux/errno.h>
#include <linux/types.h>
#include <linux/socket.h>
#include <linux/in.h>
#include <linux/kernel.h>
#include <linux/sockios.h>
#include <linux/net.h>
#include <linux/netdevice.h>
#include <linux/inet.h>
#include <linux/route.h>
#include <linux/in_route.h>
69
#include <linux/slab.h>
Linus Torvalds's avatar
Linus Torvalds committed
70 71 72 73 74 75 76 77 78 79
#include <net/sock.h>
#include <linux/mm.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/init.h>
#include <linux/rtnetlink.h>
#include <linux/string.h>
#include <linux/netfilter_decnet.h>
#include <linux/rcupdate.h>
#include <linux/times.h>
80
#include <linux/export.h>
Linus Torvalds's avatar
Linus Torvalds committed
81
#include <asm/errno.h>
82
#include <net/net_namespace.h>
83
#include <net/netlink.h>
Linus Torvalds's avatar
Linus Torvalds committed
84 85 86
#include <net/neighbour.h>
#include <net/dst.h>
#include <net/flow.h>
87
#include <net/fib_rules.h>
Linus Torvalds's avatar
Linus Torvalds committed
88 89 90 91 92 93 94 95 96
#include <net/dn.h>
#include <net/dn_dev.h>
#include <net/dn_nsp.h>
#include <net/dn_route.h>
#include <net/dn_neigh.h>
#include <net/dn_fib.h>

struct dn_rt_hash_bucket
{
97
	struct dn_route __rcu *chain;
Linus Torvalds's avatar
Linus Torvalds committed
98
	spinlock_t lock;
99
};
Linus Torvalds's avatar
Linus Torvalds committed
100 101 102 103 104 105 106 107 108 109 110 111

extern struct neigh_table dn_neigh_table;


static unsigned char dn_hiord_addr[6] = {0xAA,0x00,0x04,0x00,0x00,0x00};

static const int dn_rt_min_delay = 2 * HZ;
static const int dn_rt_max_delay = 10 * HZ;
static const int dn_rt_mtu_expires = 10 * 60 * HZ;

static unsigned long dn_rt_deadline;

112
static int dn_dst_gc(struct dst_ops *ops);
Linus Torvalds's avatar
Linus Torvalds committed
113
static struct dst_entry *dn_dst_check(struct dst_entry *, __u32);
114
static unsigned int dn_dst_default_advmss(const struct dst_entry *dst);
115
static unsigned int dn_dst_mtu(const struct dst_entry *dst);
116
static void dn_dst_destroy(struct dst_entry *);
117
static void dn_dst_ifdown(struct dst_entry *, struct net_device *dev, int how);
Linus Torvalds's avatar
Linus Torvalds committed
118 119
static struct dst_entry *dn_dst_negative_advice(struct dst_entry *);
static void dn_dst_link_failure(struct sk_buff *);
120 121 122 123
static void dn_dst_update_pmtu(struct dst_entry *dst, struct sock *sk,
			       struct sk_buff *skb , u32 mtu);
static void dn_dst_redirect(struct dst_entry *dst, struct sock *sk,
			    struct sk_buff *skb);
124 125 126
static struct neighbour *dn_dst_neigh_lookup(const struct dst_entry *dst,
					     struct sk_buff *skb,
					     const void *daddr);
Linus Torvalds's avatar
Linus Torvalds committed
127 128 129 130
static int dn_route_input(struct sk_buff *);
static void dn_run_flush(unsigned long dummy);

static struct dn_rt_hash_bucket *dn_rt_hash_table;
131
static unsigned int dn_rt_hash_mask;
Linus Torvalds's avatar
Linus Torvalds committed
132 133

static struct timer_list dn_route_timer;
134
static DEFINE_TIMER(dn_rt_flush_timer, dn_run_flush, 0, 0);
Linus Torvalds's avatar
Linus Torvalds committed
135 136 137 138 139 140 141
int decnet_dst_gc_interval = 2;

static struct dst_ops dn_dst_ops = {
	.family =		PF_DECnet,
	.gc_thresh =		128,
	.gc =			dn_dst_gc,
	.check =		dn_dst_check,
142
	.default_advmss =	dn_dst_default_advmss,
143
	.mtu =			dn_dst_mtu,
144 145
	.cow_metrics =		dst_cow_metrics_generic,
	.destroy =		dn_dst_destroy,
146
	.ifdown =		dn_dst_ifdown,
Linus Torvalds's avatar
Linus Torvalds committed
147 148 149
	.negative_advice =	dn_dst_negative_advice,
	.link_failure =		dn_dst_link_failure,
	.update_pmtu =		dn_dst_update_pmtu,
150
	.redirect =		dn_dst_redirect,
151
	.neigh_lookup =		dn_dst_neigh_lookup,
Linus Torvalds's avatar
Linus Torvalds committed
152 153
};

154 155
static void dn_dst_destroy(struct dst_entry *dst)
{
156 157 158 159
	struct dn_route *rt = (struct dn_route *) dst;

	if (rt->n)
		neigh_release(rt->n);
160 161 162
	dst_destroy_metrics_generic(dst);
}

163 164 165 166 167 168 169 170 171 172 173 174 175 176
static void dn_dst_ifdown(struct dst_entry *dst, struct net_device *dev, int how)
{
	if (how) {
		struct dn_route *rt = (struct dn_route *) dst;
		struct neighbour *n = rt->n;

		if (n && n->dev == dev) {
			n->dev = dev_net(dev)->loopback_dev;
			dev_hold(n->dev);
			dev_put(dev);
		}
	}
}

177
static __inline__ unsigned int dn_hash(__le16 src, __le16 dst)
Linus Torvalds's avatar
Linus Torvalds committed
178
{
179
	__u16 tmp = (__u16 __force)(src ^ dst);
Linus Torvalds's avatar
Linus Torvalds committed
180 181 182
	tmp ^= (tmp >> 3);
	tmp ^= (tmp >> 5);
	tmp ^= (tmp >> 10);
183
	return dn_rt_hash_mask & (unsigned int)tmp;
Linus Torvalds's avatar
Linus Torvalds committed
184 185 186 187
}

static inline void dnrt_free(struct dn_route *rt)
{
188
	call_rcu_bh(&rt->dst.rcu_head, dst_rcu_free);
Linus Torvalds's avatar
Linus Torvalds committed
189 190 191 192 193
}

static void dn_dst_check_expire(unsigned long dummy)
{
	int i;
194 195
	struct dn_route *rt;
	struct dn_route __rcu **rtp;
Linus Torvalds's avatar
Linus Torvalds committed
196 197 198
	unsigned long now = jiffies;
	unsigned long expire = 120 * HZ;

199
	for (i = 0; i <= dn_rt_hash_mask; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
200 201 202
		rtp = &dn_rt_hash_table[i].chain;

		spin_lock(&dn_rt_hash_table[i].lock);
203 204
		while ((rt = rcu_dereference_protected(*rtp,
						lockdep_is_held(&dn_rt_hash_table[i].lock))) != NULL) {
205 206 207
			if (atomic_read(&rt->dst.__refcnt) ||
					(now - rt->dst.lastuse) < expire) {
				rtp = &rt->dst.dn_next;
Linus Torvalds's avatar
Linus Torvalds committed
208 209
				continue;
			}
210 211
			*rtp = rt->dst.dn_next;
			rt->dst.dn_next = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
212 213 214 215 216 217 218 219 220 221 222
			dnrt_free(rt);
		}
		spin_unlock(&dn_rt_hash_table[i].lock);

		if ((jiffies - now) > 0)
			break;
	}

	mod_timer(&dn_route_timer, now + decnet_dst_gc_interval * HZ);
}

223
static int dn_dst_gc(struct dst_ops *ops)
Linus Torvalds's avatar
Linus Torvalds committed
224
{
225 226
	struct dn_route *rt;
	struct dn_route __rcu **rtp;
Linus Torvalds's avatar
Linus Torvalds committed
227 228 229 230
	int i;
	unsigned long now = jiffies;
	unsigned long expire = 10 * HZ;

231
	for (i = 0; i <= dn_rt_hash_mask; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
232 233 234 235

		spin_lock_bh(&dn_rt_hash_table[i].lock);
		rtp = &dn_rt_hash_table[i].chain;

236 237
		while ((rt = rcu_dereference_protected(*rtp,
						lockdep_is_held(&dn_rt_hash_table[i].lock))) != NULL) {
238 239 240
			if (atomic_read(&rt->dst.__refcnt) ||
					(now - rt->dst.lastuse) < expire) {
				rtp = &rt->dst.dn_next;
Linus Torvalds's avatar
Linus Torvalds committed
241 242
				continue;
			}
243 244
			*rtp = rt->dst.dn_next;
			rt->dst.dn_next = NULL;
245
			dnrt_free(rt);
Linus Torvalds's avatar
Linus Torvalds committed
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
			break;
		}
		spin_unlock_bh(&dn_rt_hash_table[i].lock);
	}

	return 0;
}

/*
 * The decnet standards don't impose a particular minimum mtu, what they
 * do insist on is that the routing layer accepts a datagram of at least
 * 230 bytes long. Here we have to subtract the routing header length from
 * 230 to get the minimum acceptable mtu. If there is no neighbour, then we
 * assume the worst and use a long header size.
 *
 * We update both the mtu and the advertised mss (i.e. the segment size we
 * advertise to the other end).
 */
264 265
static void dn_dst_update_pmtu(struct dst_entry *dst, struct sock *sk,
			       struct sk_buff *skb, u32 mtu)
Linus Torvalds's avatar
Linus Torvalds committed
266
{
267 268
	struct dn_route *rt = (struct dn_route *) dst;
	struct neighbour *n = rt->n;
Linus Torvalds's avatar
Linus Torvalds committed
269
	u32 min_mtu = 230;
270 271 272
	struct dn_dev *dn;

	dn = n ? rcu_dereference_raw(n->dev->dn_ptr) : NULL;
Linus Torvalds's avatar
Linus Torvalds committed
273 274 275 276 277 278

	if (dn && dn->use_long == 0)
		min_mtu -= 6;
	else
		min_mtu -= 21;

279
	if (dst_metric(dst, RTAX_MTU) > mtu && mtu >= min_mtu) {
Linus Torvalds's avatar
Linus Torvalds committed
280
		if (!(dst_metric_locked(dst, RTAX_MTU))) {
281
			dst_metric_set(dst, RTAX_MTU, mtu);
Linus Torvalds's avatar
Linus Torvalds committed
282 283 284 285
			dst_set_expires(dst, dn_rt_mtu_expires);
		}
		if (!(dst_metric_locked(dst, RTAX_ADVMSS))) {
			u32 mss = mtu - DN_MAX_NSP_DATA_HEADER;
286 287
			u32 existing_mss = dst_metric_raw(dst, RTAX_ADVMSS);
			if (!existing_mss || existing_mss > mss)
288
				dst_metric_set(dst, RTAX_ADVMSS, mss);
Linus Torvalds's avatar
Linus Torvalds committed
289 290 291 292
		}
	}
}

293 294
static void dn_dst_redirect(struct dst_entry *dst, struct sock *sk,
			    struct sk_buff *skb)
295 296 297
{
}

298
/*
Linus Torvalds's avatar
Linus Torvalds committed
299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315
 * When a route has been marked obsolete. (e.g. routing cache flush)
 */
static struct dst_entry *dn_dst_check(struct dst_entry *dst, __u32 cookie)
{
	return NULL;
}

static struct dst_entry *dn_dst_negative_advice(struct dst_entry *dst)
{
	dst_release(dst);
	return NULL;
}

static void dn_dst_link_failure(struct sk_buff *skb)
{
}

316
static inline int compare_keys(struct flowidn *fl1, struct flowidn *fl2)
Linus Torvalds's avatar
Linus Torvalds committed
317
{
318 319 320 321 322 323
	return ((fl1->daddr ^ fl2->daddr) |
		(fl1->saddr ^ fl2->saddr) |
		(fl1->flowidn_mark ^ fl2->flowidn_mark) |
		(fl1->flowidn_scope ^ fl2->flowidn_scope) |
		(fl1->flowidn_oif ^ fl2->flowidn_oif) |
		(fl1->flowidn_iif ^ fl2->flowidn_iif)) == 0;
Linus Torvalds's avatar
Linus Torvalds committed
324 325
}

326
static int dn_insert_route(struct dn_route *rt, unsigned int hash, struct dn_route **rp)
Linus Torvalds's avatar
Linus Torvalds committed
327
{
328 329
	struct dn_route *rth;
	struct dn_route __rcu **rthp;
Linus Torvalds's avatar
Linus Torvalds committed
330 331 332 333 334
	unsigned long now = jiffies;

	rthp = &dn_rt_hash_table[hash].chain;

	spin_lock_bh(&dn_rt_hash_table[hash].lock);
335 336
	while ((rth = rcu_dereference_protected(*rthp,
						lockdep_is_held(&dn_rt_hash_table[hash].lock))) != NULL) {
337
		if (compare_keys(&rth->fld, &rt->fld)) {
Linus Torvalds's avatar
Linus Torvalds committed
338
			/* Put it first */
339 340
			*rthp = rth->dst.dn_next;
			rcu_assign_pointer(rth->dst.dn_next,
Linus Torvalds's avatar
Linus Torvalds committed
341 342 343
					   dn_rt_hash_table[hash].chain);
			rcu_assign_pointer(dn_rt_hash_table[hash].chain, rth);

344
			dst_use(&rth->dst, now);
Linus Torvalds's avatar
Linus Torvalds committed
345 346
			spin_unlock_bh(&dn_rt_hash_table[hash].lock);

347
			dst_free(&rt->dst);
Linus Torvalds's avatar
Linus Torvalds committed
348 349 350
			*rp = rth;
			return 0;
		}
351
		rthp = &rth->dst.dn_next;
Linus Torvalds's avatar
Linus Torvalds committed
352 353
	}

354
	rcu_assign_pointer(rt->dst.dn_next, dn_rt_hash_table[hash].chain);
Linus Torvalds's avatar
Linus Torvalds committed
355
	rcu_assign_pointer(dn_rt_hash_table[hash].chain, rt);
356

357
	dst_use(&rt->dst, now);
Linus Torvalds's avatar
Linus Torvalds committed
358 359 360 361 362
	spin_unlock_bh(&dn_rt_hash_table[hash].lock);
	*rp = rt;
	return 0;
}

Roel Kluin's avatar
Roel Kluin committed
363
static void dn_run_flush(unsigned long dummy)
Linus Torvalds's avatar
Linus Torvalds committed
364 365 366 367
{
	int i;
	struct dn_route *rt, *next;

368
	for (i = 0; i < dn_rt_hash_mask; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
369 370
		spin_lock_bh(&dn_rt_hash_table[i].lock);

371
		if ((rt = xchg((struct dn_route **)&dn_rt_hash_table[i].chain, NULL)) == NULL)
Linus Torvalds's avatar
Linus Torvalds committed
372 373
			goto nothing_to_declare;

374 375 376
		for(; rt; rt = next) {
			next = rcu_dereference_raw(rt->dst.dn_next);
			RCU_INIT_POINTER(rt->dst.dn_next, NULL);
377
			dnrt_free(rt);
Linus Torvalds's avatar
Linus Torvalds committed
378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429
		}

nothing_to_declare:
		spin_unlock_bh(&dn_rt_hash_table[i].lock);
	}
}

static DEFINE_SPINLOCK(dn_rt_flush_lock);

void dn_rt_cache_flush(int delay)
{
	unsigned long now = jiffies;
	int user_mode = !in_interrupt();

	if (delay < 0)
		delay = dn_rt_min_delay;

	spin_lock_bh(&dn_rt_flush_lock);

	if (del_timer(&dn_rt_flush_timer) && delay > 0 && dn_rt_deadline) {
		long tmo = (long)(dn_rt_deadline - now);

		if (user_mode && tmo < dn_rt_max_delay - dn_rt_min_delay)
			tmo = 0;

		if (delay > tmo)
			delay = tmo;
	}

	if (delay <= 0) {
		spin_unlock_bh(&dn_rt_flush_lock);
		dn_run_flush(0);
		return;
	}

	if (dn_rt_deadline == 0)
		dn_rt_deadline = now + dn_rt_max_delay;

	dn_rt_flush_timer.expires = now + delay;
	add_timer(&dn_rt_flush_timer);
	spin_unlock_bh(&dn_rt_flush_lock);
}

/**
 * dn_return_short - Return a short packet to its sender
 * @skb: The packet to return
 *
 */
static int dn_return_short(struct sk_buff *skb)
{
	struct dn_skb_cb *cb;
	unsigned char *ptr;
430 431
	__le16 *src;
	__le16 *dst;
Linus Torvalds's avatar
Linus Torvalds committed
432 433

	/* Add back headers */
434
	skb_push(skb, skb->data - skb_network_header(skb));
Linus Torvalds's avatar
Linus Torvalds committed
435 436 437 438 439 440 441 442 443

	if ((skb = skb_unshare(skb, GFP_ATOMIC)) == NULL)
		return NET_RX_DROP;

	cb = DN_SKB_CB(skb);
	/* Skip packet length and point to flags */
	ptr = skb->data + 2;
	*ptr++ = (cb->rt_flags & ~DN_RT_F_RQR) | DN_RT_F_RTS;

444
	dst = (__le16 *)ptr;
Linus Torvalds's avatar
Linus Torvalds committed
445
	ptr += 2;
446
	src = (__le16 *)ptr;
Linus Torvalds's avatar
Linus Torvalds committed
447 448 449
	ptr += 2;
	*ptr = 0; /* Zero hop count */

450
	swap(*src, *dst);
Linus Torvalds's avatar
Linus Torvalds committed
451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469

	skb->pkt_type = PACKET_OUTGOING;
	dn_rt_finish_output(skb, NULL, NULL);
	return NET_RX_SUCCESS;
}

/**
 * dn_return_long - Return a long packet to its sender
 * @skb: The long format packet to return
 *
 */
static int dn_return_long(struct sk_buff *skb)
{
	struct dn_skb_cb *cb;
	unsigned char *ptr;
	unsigned char *src_addr, *dst_addr;
	unsigned char tmp[ETH_ALEN];

	/* Add back all headers */
470
	skb_push(skb, skb->data - skb_network_header(skb));
Linus Torvalds's avatar
Linus Torvalds committed
471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508

	if ((skb = skb_unshare(skb, GFP_ATOMIC)) == NULL)
		return NET_RX_DROP;

	cb = DN_SKB_CB(skb);
	/* Ignore packet length and point to flags */
	ptr = skb->data + 2;

	/* Skip padding */
	if (*ptr & DN_RT_F_PF) {
		char padlen = (*ptr & ~DN_RT_F_PF);
		ptr += padlen;
	}

	*ptr++ = (cb->rt_flags & ~DN_RT_F_RQR) | DN_RT_F_RTS;
	ptr += 2;
	dst_addr = ptr;
	ptr += 8;
	src_addr = ptr;
	ptr += 6;
	*ptr = 0; /* Zero hop count */

	/* Swap source and destination */
	memcpy(tmp, src_addr, ETH_ALEN);
	memcpy(src_addr, dst_addr, ETH_ALEN);
	memcpy(dst_addr, tmp, ETH_ALEN);

	skb->pkt_type = PACKET_OUTGOING;
	dn_rt_finish_output(skb, dst_addr, src_addr);
	return NET_RX_SUCCESS;
}

/**
 * dn_route_rx_packet - Try and find a route for an incoming packet
 * @skb: The packet to find a route for
 *
 * Returns: result of input function if route is found, error code otherwise
 */
509
static int dn_route_rx_packet(struct net *net, struct sock *sk, struct sk_buff *skb)
Linus Torvalds's avatar
Linus Torvalds committed
510
{
511
	struct dn_skb_cb *cb;
Linus Torvalds's avatar
Linus Torvalds committed
512 513 514 515 516
	int err;

	if ((err = dn_route_input(skb)) == 0)
		return dst_input(skb);

517
	cb = DN_SKB_CB(skb);
Linus Torvalds's avatar
Linus Torvalds committed
518 519
	if (decnet_debug_level & 4) {
		char *devname = skb->dev ? skb->dev->name : "???";
520

Linus Torvalds's avatar
Linus Torvalds committed
521 522
		printk(KERN_DEBUG
			"DECnet: dn_route_rx_packet: rt_flags=0x%02x dev=%s len=%d src=0x%04hx dst=0x%04hx err=%d type=%d\n",
523
			(int)cb->rt_flags, devname, skb->len,
524
			le16_to_cpu(cb->src), le16_to_cpu(cb->dst),
Linus Torvalds's avatar
Linus Torvalds committed
525 526 527 528
			err, skb->pkt_type);
	}

	if ((skb->pkt_type == PACKET_HOST) && (cb->rt_flags & DN_RT_F_RQR)) {
529 530 531 532 533
		switch (cb->rt_flags & DN_RT_PKT_MSK) {
		case DN_RT_PKT_SHORT:
			return dn_return_short(skb);
		case DN_RT_PKT_LONG:
			return dn_return_long(skb);
Linus Torvalds's avatar
Linus Torvalds committed
534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549
		}
	}

	kfree_skb(skb);
	return NET_RX_DROP;
}

static int dn_route_rx_long(struct sk_buff *skb)
{
	struct dn_skb_cb *cb = DN_SKB_CB(skb);
	unsigned char *ptr = skb->data;

	if (!pskb_may_pull(skb, 21)) /* 20 for long header, 1 for shortest nsp */
		goto drop_it;

	skb_pull(skb, 20);
550
	skb_reset_transport_header(skb);
Linus Torvalds's avatar
Linus Torvalds committed
551

552 553
	/* Destination info */
	ptr += 2;
554
	cb->dst = dn_eth2dn(ptr);
555 556 557
	if (memcmp(ptr, dn_hiord_addr, 4) != 0)
		goto drop_it;
	ptr += 6;
Linus Torvalds's avatar
Linus Torvalds committed
558 559


560 561
	/* Source info */
	ptr += 2;
562
	cb->src = dn_eth2dn(ptr);
563 564 565 566 567 568
	if (memcmp(ptr, dn_hiord_addr, 4) != 0)
		goto drop_it;
	ptr += 6;
	/* Other junk */
	ptr++;
	cb->hops = *ptr++; /* Visit Count */
Linus Torvalds's avatar
Linus Torvalds committed
569

570 571
	return NF_HOOK(NFPROTO_DECNET, NF_DN_PRE_ROUTING,
		       &init_net, NULL, skb, skb->dev, NULL,
572
		       dn_route_rx_packet);
Linus Torvalds's avatar
Linus Torvalds committed
573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589

drop_it:
	kfree_skb(skb);
	return NET_RX_DROP;
}



static int dn_route_rx_short(struct sk_buff *skb)
{
	struct dn_skb_cb *cb = DN_SKB_CB(skb);
	unsigned char *ptr = skb->data;

	if (!pskb_may_pull(skb, 6)) /* 5 for short header + 1 for shortest nsp */
		goto drop_it;

	skb_pull(skb, 5);
590
	skb_reset_transport_header(skb);
Linus Torvalds's avatar
Linus Torvalds committed
591

592
	cb->dst = *(__le16 *)ptr;
593 594 595 596
	ptr += 2;
	cb->src = *(__le16 *)ptr;
	ptr += 2;
	cb->hops = *ptr & 0x3f;
Linus Torvalds's avatar
Linus Torvalds committed
597

598 599
	return NF_HOOK(NFPROTO_DECNET, NF_DN_PRE_ROUTING,
		       &init_net, NULL, skb, skb->dev, NULL,
600
		       dn_route_rx_packet);
Linus Torvalds's avatar
Linus Torvalds committed
601 602

drop_it:
603 604
	kfree_skb(skb);
	return NET_RX_DROP;
Linus Torvalds's avatar
Linus Torvalds committed
605 606
}

607
static int dn_route_discard(struct net *net, struct sock *sk, struct sk_buff *skb)
Linus Torvalds's avatar
Linus Torvalds committed
608 609 610 611 612 613 614 615 616
{
	/*
	 * I know we drop the packet here, but thats considered success in
	 * this case
	 */
	kfree_skb(skb);
	return NET_RX_SUCCESS;
}

617
static int dn_route_ptp_hello(struct net *net, struct sock *sk, struct sk_buff *skb)
Linus Torvalds's avatar
Linus Torvalds committed
618 619 620 621 622 623
{
	dn_dev_hello(skb);
	dn_neigh_pointopoint_hello(skb);
	return NET_RX_SUCCESS;
}

David S. Miller's avatar
David S. Miller committed
624
int dn_route_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
Linus Torvalds's avatar
Linus Torvalds committed
625 626 627
{
	struct dn_skb_cb *cb;
	unsigned char flags = 0;
628
	__u16 len = le16_to_cpu(*(__le16 *)skb->data);
629
	struct dn_dev *dn = rcu_dereference(dev->dn_ptr);
Linus Torvalds's avatar
Linus Torvalds committed
630 631
	unsigned char padlen = 0;

632
	if (!net_eq(dev_net(dev), &init_net))
633 634
		goto dump_it;

Linus Torvalds's avatar
Linus Torvalds committed
635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667
	if (dn == NULL)
		goto dump_it;

	if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
		goto out;

	if (!pskb_may_pull(skb, 3))
		goto dump_it;

	skb_pull(skb, 2);

	if (len > skb->len)
		goto dump_it;

	skb_trim(skb, len);

	flags = *skb->data;

	cb = DN_SKB_CB(skb);
	cb->stamp = jiffies;
	cb->iif = dev->ifindex;

	/*
	 * If we have padding, remove it.
	 */
	if (flags & DN_RT_F_PF) {
		padlen = flags & ~DN_RT_F_PF;
		if (!pskb_may_pull(skb, padlen + 1))
			goto dump_it;
		skb_pull(skb, padlen);
		flags = *skb->data;
	}

668
	skb_reset_network_header(skb);
Linus Torvalds's avatar
Linus Torvalds committed
669 670 671 672 673 674 675 676 677 678

	/*
	 * Weed out future version DECnet
	 */
	if (flags & DN_RT_F_VER)
		goto dump_it;

	cb->rt_flags = flags;

	if (decnet_debug_level & 1)
679
		printk(KERN_DEBUG
Linus Torvalds's avatar
Linus Torvalds committed
680
			"dn_route_rcv: got 0x%02x from %s [%d %d %d]\n",
681
			(int)flags, (dev) ? dev->name : "???", len, skb->len,
Linus Torvalds's avatar
Linus Torvalds committed
682 683
			padlen);

684
	if (flags & DN_RT_PKT_CNTL) {
Herbert Xu's avatar
Herbert Xu committed
685
		if (unlikely(skb_linearize(skb)))
Linus Torvalds's avatar
Linus Torvalds committed
686 687
			goto dump_it;

688 689 690 691 692 693 694
		switch (flags & DN_RT_CNTL_MSK) {
		case DN_RT_PKT_INIT:
			dn_dev_init_pkt(skb);
			break;
		case DN_RT_PKT_VERI:
			dn_dev_veri_pkt(skb);
			break;
Linus Torvalds's avatar
Linus Torvalds committed
695 696 697 698 699
		}

		if (dn->parms.state != DN_DEV_S_RU)
			goto dump_it;

700 701 702
		switch (flags & DN_RT_CNTL_MSK) {
		case DN_RT_PKT_HELO:
			return NF_HOOK(NFPROTO_DECNET, NF_DN_HELLO,
703
				       &init_net, NULL, skb, skb->dev, NULL,
704 705 706 707 708
				       dn_route_ptp_hello);

		case DN_RT_PKT_L1RT:
		case DN_RT_PKT_L2RT:
			return NF_HOOK(NFPROTO_DECNET, NF_DN_ROUTE,
709
				       &init_net, NULL, skb, skb->dev, NULL,
710 711 712
				       dn_route_discard);
		case DN_RT_PKT_ERTH:
			return NF_HOOK(NFPROTO_DECNET, NF_DN_HELLO,
713
				       &init_net, NULL, skb, skb->dev, NULL,
714 715 716 717
				       dn_neigh_router_hello);

		case DN_RT_PKT_EEDH:
			return NF_HOOK(NFPROTO_DECNET, NF_DN_HELLO,
718
				       &init_net, NULL, skb, skb->dev, NULL,
719
				       dn_neigh_endnode_hello);
720 721
		}
	} else {
Linus Torvalds's avatar
Linus Torvalds committed
722 723 724 725 726
		if (dn->parms.state != DN_DEV_S_RU)
			goto dump_it;

		skb_pull(skb, 1); /* Pull flags */

727 728 729 730 731
		switch (flags & DN_RT_PKT_MSK) {
		case DN_RT_PKT_LONG:
			return dn_route_rx_long(skb);
		case DN_RT_PKT_SHORT:
			return dn_route_rx_short(skb);
Linus Torvalds's avatar
Linus Torvalds committed
732
		}
733
	}
Linus Torvalds's avatar
Linus Torvalds committed
734 735 736 737 738 739 740

dump_it:
	kfree_skb(skb);
out:
	return NET_RX_DROP;
}

741
static int dn_output(struct net *net, struct sock *sk, struct sk_buff *skb)
Linus Torvalds's avatar
Linus Torvalds committed
742
{
Eric Dumazet's avatar
Eric Dumazet committed
743
	struct dst_entry *dst = skb_dst(skb);
Linus Torvalds's avatar
Linus Torvalds committed
744 745 746 747 748 749
	struct dn_route *rt = (struct dn_route *)dst;
	struct net_device *dev = dst->dev;
	struct dn_skb_cb *cb = DN_SKB_CB(skb);

	int err = -EINVAL;

750
	if (rt->n == NULL)
Linus Torvalds's avatar
Linus Torvalds committed
751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766
		goto error;

	skb->dev = dev;

	cb->src = rt->rt_saddr;
	cb->dst = rt->rt_daddr;

	/*
	 * Always set the Intra-Ethernet bit on all outgoing packets
	 * originated on this node. Only valid flag from upper layers
	 * is return-to-sender-requested. Set hop count to 0 too.
	 */
	cb->rt_flags &= ~DN_RT_F_RQR;
	cb->rt_flags |= DN_RT_F_IE;
	cb->hops = 0;

767 768
	return NF_HOOK(NFPROTO_DECNET, NF_DN_LOCAL_OUT,
		       &init_net, sk, skb, NULL, dev,
769
		       dn_to_neigh_output);
Linus Torvalds's avatar
Linus Torvalds committed
770 771

error:
772
	net_dbg_ratelimited("dn_output: This should not happen\n");
Linus Torvalds's avatar
Linus Torvalds committed
773 774 775 776 777 778 779 780 781

	kfree_skb(skb);

	return err;
}

static int dn_forward(struct sk_buff *skb)
{
	struct dn_skb_cb *cb = DN_SKB_CB(skb);
Eric Dumazet's avatar
Eric Dumazet committed
782
	struct dst_entry *dst = skb_dst(skb);
783
	struct dn_dev *dn_db = rcu_dereference(dst->dev->dn_ptr);
Linus Torvalds's avatar
Linus Torvalds committed
784 785 786 787 788 789 790 791
	struct dn_route *rt;
	int header_len;
	struct net_device *dev = skb->dev;

	if (skb->pkt_type != PACKET_HOST)
		goto drop;

	/* Ensure that we have enough space for headers */
Eric Dumazet's avatar
Eric Dumazet committed
792
	rt = (struct dn_route *)skb_dst(skb);
Linus Torvalds's avatar
Linus Torvalds committed
793
	header_len = dn_db->use_long ? 21 : 6;
794
	if (skb_cow(skb, LL_RESERVED_SPACE(rt->dst.dev)+header_len))
Linus Torvalds's avatar
Linus Torvalds committed
795 796 797 798 799 800 801 802
		goto drop;

	/*
	 * Hop count exceeded.
	 */
	if (++cb->hops > 30)
		goto drop;

803
	skb->dev = rt->dst.dev;
Linus Torvalds's avatar
Linus Torvalds committed
804 805 806 807 808 809 810 811 812 813

	/*
	 * If packet goes out same interface it came in on, then set
	 * the Intra-Ethernet bit. This has no effect for short
	 * packets, so we don't need to test for them here.
	 */
	cb->rt_flags &= ~DN_RT_F_IE;
	if (rt->rt_flags & RTCF_DOREDIRECT)
		cb->rt_flags |= DN_RT_F_IE;

814 815
	return NF_HOOK(NFPROTO_DECNET, NF_DN_FORWARD,
		       &init_net, NULL, skb, dev, skb->dev,
816
		       dn_to_neigh_output);
Linus Torvalds's avatar
Linus Torvalds committed
817 818 819 820 821 822 823 824 825 826

drop:
	kfree_skb(skb);
	return NET_RX_DROP;
}

/*
 * Used to catch bugs. This should never normally get
 * called.
 */
827
static int dn_rt_bug_out(struct net *net, struct sock *sk, struct sk_buff *skb)
828 829 830 831 832 833 834 835 836 837 838
{
	struct dn_skb_cb *cb = DN_SKB_CB(skb);

	net_dbg_ratelimited("dn_rt_bug: skb from:%04x to:%04x\n",
			    le16_to_cpu(cb->src), le16_to_cpu(cb->dst));

	kfree_skb(skb);

	return NET_RX_DROP;
}

Linus Torvalds's avatar
Linus Torvalds committed
839 840
static int dn_rt_bug(struct sk_buff *skb)
{
841
	struct dn_skb_cb *cb = DN_SKB_CB(skb);
Linus Torvalds's avatar
Linus Torvalds committed
842

843 844
	net_dbg_ratelimited("dn_rt_bug: skb from:%04x to:%04x\n",
			    le16_to_cpu(cb->src), le16_to_cpu(cb->dst));
Linus Torvalds's avatar
Linus Torvalds committed
845 846 847

	kfree_skb(skb);

848
	return NET_RX_DROP;
Linus Torvalds's avatar
Linus Torvalds committed
849 850
}

851 852 853 854 855
static unsigned int dn_dst_default_advmss(const struct dst_entry *dst)
{
	return dn_mss_from_pmtu(dst->dev, dst_mtu(dst));
}

856
static unsigned int dn_dst_mtu(const struct dst_entry *dst)
857
{
858 859 860
	unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);

	return mtu ? : dst->dev->mtu;
861 862
}

863 864 865
static struct neighbour *dn_dst_neigh_lookup(const struct dst_entry *dst,
					     struct sk_buff *skb,
					     const void *daddr)
866 867 868 869
{
	return __neigh_lookup_errno(&dn_neigh_table, daddr, dst->dev);
}

Linus Torvalds's avatar
Linus Torvalds committed
870 871 872
static int dn_rt_set_next_hop(struct dn_route *rt, struct dn_fib_res *res)
{
	struct dn_fib_info *fi = res->fi;
873
	struct net_device *dev = rt->dst.dev;
874
	unsigned int mss_metric;
Linus Torvalds's avatar
Linus Torvalds committed
875 876 877 878 879 880
	struct neighbour *n;

	if (fi) {
		if (DN_FIB_RES_GW(*res) &&
		    DN_FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK)
			rt->rt_gateway = DN_FIB_RES_GW(*res);
881
		dst_init_metrics(&rt->dst, fi->fib_metrics, true);
Linus Torvalds's avatar
Linus Torvalds committed
882 883 884
	}
	rt->rt_type = res->type;

885
	if (dev != NULL && rt->n == NULL) {
Linus Torvalds's avatar
Linus Torvalds committed
886 887 888
		n = __neigh_lookup_errno(&dn_neigh_table, &rt->rt_gateway, dev);
		if (IS_ERR(n))
			return PTR_ERR(n);
889
		rt->n = n;
Linus Torvalds's avatar
Linus Torvalds committed
890 891
	}

892
	if (dst_metric(&rt->dst, RTAX_MTU) > rt->dst.dev->mtu)
893
		dst_metric_set(&rt->dst, RTAX_MTU, rt->dst.dev->mtu);
894 895
	mss_metric = dst_metric_raw(&rt->dst, RTAX_ADVMSS);
	if (mss_metric) {
896
		unsigned int mss = dn_mss_from_pmtu(dev, dst_mtu(&rt->dst));
897
		if (mss_metric > mss)
898 899
			dst_metric_set(&rt->dst, RTAX_ADVMSS, mss);
	}
Linus Torvalds's avatar
Linus Torvalds committed
900 901 902
	return 0;
}

903
static inline int dn_match_addr(__le16 addr1, __le16 addr2)
Linus Torvalds's avatar
Linus Torvalds committed
904
{
905
	__u16 tmp = le16_to_cpu(addr1) ^ le16_to_cpu(addr2);
Linus Torvalds's avatar
Linus Torvalds committed
906 907 908 909 910 911 912 913
	int match = 16;
	while(tmp) {
		tmp >>= 1;
		match--;
	}
	return match;
}

914
static __le16 dnet_select_source(const struct net_device *dev, __le16 daddr, int scope)
Linus Torvalds's avatar
Linus Torvalds committed
915
{
916
	__le16 saddr = 0;
917
	struct dn_dev *dn_db;
Linus Torvalds's avatar
Linus Torvalds committed
918 919 920 921
	struct dn_ifaddr *ifa;
	int best_match = 0;
	int ret;

922 923 924 925 926
	rcu_read_lock();
	dn_db = rcu_dereference(dev->dn_ptr);
	for (ifa = rcu_dereference(dn_db->ifa_list);
	     ifa != NULL;
	     ifa = rcu_dereference(ifa->ifa_next)) {
Linus Torvalds's avatar
Linus Torvalds committed
927 928 929 930 931 932 933 934 935 936 937 938
		if (ifa->ifa_scope > scope)
			continue;
		if (!daddr) {
			saddr = ifa->ifa_local;
			break;
		}
		ret = dn_match_addr(daddr, ifa->ifa_local);
		if (ret > best_match)
			saddr = ifa->ifa_local;
		if (best_match == 0)
			saddr = ifa->ifa_local;
	}
939
	rcu_read_unlock();
Linus Torvalds's avatar
Linus Torvalds committed
940 941 942 943

	return saddr;
}

944
static inline __le16 __dn_fib_res_prefsrc(struct dn_fib_res *res)
Linus Torvalds's avatar
Linus Torvalds committed
945 946 947 948
{
	return dnet_select_source(DN_FIB_RES_DEV(*res), DN_FIB_RES_GW(*res), res->scope);
}

949
static inline __le16 dn_fib_rules_map_destination(__le16 daddr, struct dn_fib_res *res)
Linus Torvalds's avatar
Linus Torvalds committed
950
{
951
	__le16 mask = dnet_make_mask(res->prefixlen);
Linus Torvalds's avatar
Linus Torvalds committed
952 953 954
	return (daddr&~mask)|res->fi->fib_nh->nh_gw;
}

955
static int dn_route_output_slow(struct dst_entry **pprt, const struct flowidn *oldflp, int try_hard)
Linus Torvalds's avatar
Linus Torvalds committed
956
{
957 958 959 960 961
	struct flowidn fld = {
		.daddr = oldflp->daddr,
		.saddr = oldflp->saddr,
		.flowidn_scope = RT_SCOPE_UNIVERSE,
		.flowidn_mark = oldflp->flowidn_mark,
962
		.flowidn_iif = LOOPBACK_IFINDEX,
963
		.flowidn_oif = oldflp->flowidn_oif,
964
	};
Linus Torvalds's avatar
Linus Torvalds committed
965
	struct dn_route *rt = NULL;
966
	struct net_device *dev_out = NULL, *dev;
Linus Torvalds's avatar
Linus Torvalds committed
967
	struct neighbour *neigh = NULL;
968 969
	unsigned int hash;
	unsigned int flags = 0;
Linus Torvalds's avatar
Linus Torvalds committed
970 971 972
	struct dn_fib_res res = { .fi = NULL, .type = RTN_UNICAST };
	int err;
	int free_res = 0;
973
	__le16 gateway = 0;
Linus Torvalds's avatar
Linus Torvalds committed
974 975 976 977

	if (decnet_debug_level & 16)
		printk(KERN_DEBUG
		       "dn_route_output_slow: dst=%04x src=%04x mark=%d"
978 979
		       " iif=%d oif=%d\n", le16_to_cpu(oldflp->daddr),
		       le16_to_cpu(oldflp->saddr),
980
		       oldflp->flowidn_mark, LOOPBACK_IFINDEX,
981
		       oldflp->flowidn_oif);
Linus Torvalds's avatar
Linus Torvalds committed
982 983

	/* If we have an output interface, verify its a DECnet device */
984 985
	if (oldflp->flowidn_oif) {
		dev_out = dev_get_by_index(&init_net, oldflp->flowidn_oif);
Linus Torvalds's avatar
Linus Torvalds committed
986 987 988 989 990 991 992 993 994 995
		err = -ENODEV;
		if (dev_out && dev_out->dn_ptr == NULL) {
			dev_put(dev_out);
			dev_out = NULL;
		}
		if (dev_out == NULL)
			goto out;
	}

	/* If we have a source address, verify that its a local address */
996
	if (oldflp->saddr) {
Linus Torvalds's avatar
Linus Torvalds committed
997 998 999
		err = -EADDRNOTAVAIL;

		if (dev_out) {
1000
			if (dn_dev_islocal(dev_out, oldflp->saddr))
Linus Torvalds's avatar
Linus Torvalds committed
1001 1002 1003 1004
				goto source_ok;
			dev_put(dev_out);
			goto out;
		}
1005 1006
		rcu_read_lock();
		for_each_netdev_rcu(&init_net, dev) {
1007
			if (!dev->dn_ptr)
Linus Torvalds's avatar
Linus Torvalds committed
1008
				continue;
1009
			if (!dn_dev_islocal(dev, oldflp->saddr))
1010
				continue;
1011
			if ((dev->flags & IFF_LOOPBACK) &&
1012 1013
			    oldflp->daddr &&
			    !dn_dev_islocal(dev, oldflp->daddr))
1014
				continue;
1015 1016

			dev_out = dev;
1017
			break;
Linus Torvalds's avatar
Linus Torvalds committed
1018
		}
1019
		rcu_read_unlock();
Linus Torvalds's avatar
Linus Torvalds committed
1020 1021 1022 1023 1024 1025 1026 1027
		if (dev_out == NULL)
			goto out;
		dev_hold(dev_out);
source_ok:
		;
	}

	/* No destination? Assume its local */
1028 1029
	if (!fld.daddr) {
		fld.daddr = fld.saddr;
Linus Torvalds's avatar
Linus Torvalds committed
1030 1031 1032

		if (dev_out)
			dev_put(dev_out);
1033
		err = -EINVAL;
1034
		dev_out = init_net.loopback_dev;
1035 1036 1037
		if (!dev_out->dn_ptr)
			goto out;
		err = -EADDRNOTAVAIL;
Linus Torvalds's avatar
Linus Torvalds committed
1038
		dev_hold(dev_out);
1039 1040 1041
		if (!fld.daddr) {
			fld.daddr =
			fld.saddr = dnet_select_source(dev_out, 0,
Linus Torvalds's avatar
Linus Torvalds committed
1042
						       RT_SCOPE_HOST);
1043
			if (!fld.daddr)
Linus Torvalds's avatar
Linus Torvalds committed
1044 1045
				goto out;
		}
1046
		fld.flowidn_oif = LOOPBACK_IFINDEX;
Linus Torvalds's avatar
Linus Torvalds committed
1047 1048 1049 1050 1051 1052 1053
		res.type = RTN_LOCAL;
		goto make_route;
	}

	if (decnet_debug_level & 16)
		printk(KERN_DEBUG
		       "dn_route_output_slow: initial checks complete."
1054
		       " dst=%04x src=%04x oif=%d try_hard=%d\n",
1055 1056
		       le16_to_cpu(fld.daddr), le16_to_cpu(fld.saddr),
		       fld.flowidn_oif, try_hard);
Linus Torvalds's avatar
Linus Torvalds committed
1057 1058 1059 1060 1061 1062 1063

	/*
	 * N.B. If the kernel is compiled without router support then
	 * dn_fib_lookup() will evaluate to non-zero so this if () block
	 * will always be executed.
	 */
	err = -ESRCH;
1064
	if (try_hard || (err = dn_fib_lookup(&fld, &res)) != 0) {
Linus Torvalds's avatar
Linus Torvalds committed
1065 1066 1067 1068
		struct dn_dev *dn_db;
		if (err != -ESRCH)
			goto out;
		/*
1069
		 * Here the fallback is basically the standard algorithm for
Linus Torvalds's avatar
Linus Torvalds committed
1070 1071 1072 1073 1074
		 * routing in endnodes which is described in the DECnet routing
		 * docs
		 *
		 * If we are not trying hard, look in neighbour cache.
		 * The result is tested to ensure that if a specific output
1075
		 * device/source address was requested, then we honour that
Linus Torvalds's avatar
Linus Torvalds committed
1076 1077 1078
		 * here
		 */
		if (!try_hard) {
1079
			neigh = neigh_lookup_nodev(&dn_neigh_table, &init_net, &fld.daddr);
Linus Torvalds's avatar
Linus Torvalds committed
1080
			if (neigh) {
1081 1082 1083
				if ((oldflp->flowidn_oif &&
				    (neigh->dev->ifindex != oldflp->flowidn_oif)) ||
				    (oldflp->saddr &&
Linus Torvalds's avatar
Linus Torvalds committed
1084
				    (!dn_dev_islocal(neigh->dev,
1085
						     oldflp->saddr)))) {
Linus Torvalds's avatar
Linus Torvalds committed
1086 1087 1088 1089 1090
					neigh_release(neigh);
					neigh = NULL;
				} else {
					if (dev_out)
						dev_put(dev_out);
1091
					if (dn_dev_islocal(neigh->dev, fld.daddr)) {
1092
						dev_out = init_net.loopback_dev;
Linus Torvalds's avatar
Linus Torvalds committed
1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108
						res.type = RTN_LOCAL;
					} else {
						dev_out = neigh->dev;
					}
					dev_hold(dev_out);
					goto select_source;
				}
			}
		}

		/* Not there? Perhaps its a local address */
		if (dev_out == NULL)
			dev_out = dn_dev_get_default();
		err = -ENODEV;
		if (dev_out == NULL)
			goto out;
1109
		dn_db = rcu_dereference_raw(dev_out->dn_ptr);
1110 1111
		if (!dn_db)
			goto e_inval;
Linus Torvalds's avatar
Linus Torvalds committed
1112
		/* Possible improvement - check all devices for local addr */
1113
		if (dn_dev_islocal(dev_out, fld.daddr)) {
Linus Torvalds's avatar
Linus Torvalds committed
1114
			dev_put(dev_out);
1115
			dev_out = init_net.loopback_dev;
Linus Torvalds's avatar
Linus Torvalds committed
1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128
			dev_hold(dev_out);
			res.type = RTN_LOCAL;
			goto select_source;
		}
		/* Not local either.... try sending it to the default router */
		neigh = neigh_clone(dn_db->router);
		BUG_ON(neigh && neigh->dev != dev_out);

		/* Ok then, we assume its directly connected and move on */
select_source:
		if (neigh)
			gateway = ((struct dn_neigh *)neigh)->addr;
		if (gateway == 0)
1129 1130 1131 1132 1133 1134 1135
			gateway = fld.daddr;
		if (fld.saddr == 0) {
			fld.saddr = dnet_select_source(dev_out, gateway,
						       res.type == RTN_LOCAL ?
						       RT_SCOPE_HOST :
						       RT_SCOPE_LINK);
			if (fld.saddr == 0 && res.type != RTN_LOCAL)
Linus Torvalds's avatar
Linus Torvalds committed
1136 1137
				goto e_addr;
		}
1138
		fld.flowidn_oif = dev_out->ifindex;
Linus Torvalds's avatar
Linus Torvalds committed
1139 1140 1141 1142 1143 1144 1145 1146
		goto make_route;
	}
	free_res = 1;

	if (res.type == RTN_NAT)
		goto e_inval;

	if (res.type == RTN_LOCAL) {
1147 1148
		if (!fld.saddr)
			fld.saddr = fld.daddr;
Linus Torvalds's avatar
Linus Torvalds committed
1149 1150
		if (dev_out)
			dev_put(dev_out);
1151
		dev_out = init_net.loopback_dev;
Linus Torvalds's avatar
Linus Torvalds committed
1152
		dev_hold(dev_out);
1153 1154
		if (!dev_out->dn_ptr)
			goto e_inval;
1155
		fld.flowidn_oif = dev_out->ifindex;
Linus Torvalds's avatar
Linus Torvalds committed
1156 1157 1158 1159 1160 1161
		if (res.fi)
			dn_fib_info_put(res.fi);
		res.fi = NULL;
		goto make_route;
	}

1162 1163
	if (res.fi->fib_nhs > 1 && fld.flowidn_oif == 0)
		dn_fib_select_multipath(&fld, &res);
Linus Torvalds's avatar
Linus Torvalds committed
1164

1165
	/*
Linus Torvalds's avatar
Linus Torvalds committed
1166 1167 1168 1169
	 * We could add some logic to deal with default routes here and
	 * get rid of some of the special casing above.
	 */

1170 1171
	if (!fld.saddr)
		fld.saddr = DN_FIB_RES_PREFSRC(res);
1172

Linus Torvalds's avatar
Linus Torvalds committed
1173 1174 1175 1176
	if (dev_out)
		dev_put(dev_out);
	dev_out = DN_FIB_RES_DEV(res);
	dev_hold(dev_out);
1177
	fld.flowidn_oif = dev_out->ifindex;
Linus Torvalds's avatar
Linus Torvalds committed
1178 1179 1180 1181 1182 1183
	gateway = DN_FIB_RES_GW(res);

make_route:
	if (dev_out->flags & IFF_LOOPBACK)
		flags |= RTCF_LOCAL;

1184
	rt = dst_alloc(&dn_dst_ops, dev_out, 0, DST_OBSOLETE_NONE, DST_HOST);
Linus Torvalds's avatar
Linus Torvalds committed
1185 1186 1187
	if (rt == NULL)
		goto e_nobufs;

1188
	memset(&rt->fld, 0, sizeof(rt->fld));
1189 1190 1191 1192 1193
	rt->fld.saddr        = oldflp->saddr;
	rt->fld.daddr        = oldflp->daddr;
	rt->fld.flowidn_oif  = oldflp->flowidn_oif;
	rt->fld.flowidn_iif  = 0;
	rt->fld.flowidn_mark = oldflp->flowidn_mark;
Linus Torvalds's avatar
Linus Torvalds committed
1194

1195 1196 1197 1198
	rt->rt_saddr      = fld.saddr;
	rt->rt_daddr      = fld.daddr;
	rt->rt_gateway    = gateway ? gateway : fld.daddr;
	rt->rt_local_src  = fld.saddr;
Linus Torvalds's avatar
Linus Torvalds committed
1199

1200 1201
	rt->rt_dst_map    = fld.daddr;
	rt->rt_src_map    = fld.saddr;
Linus Torvalds's avatar
Linus Torvalds committed
1202

1203
	rt->n = neigh;
Linus Torvalds's avatar
Linus Torvalds committed
1204 1205
	neigh = NULL;

1206 1207 1208
	rt->dst.lastuse = jiffies;
	rt->dst.output  = dn_output;
	rt->dst.input   = dn_rt_bug;
Linus Torvalds's avatar
Linus Torvalds committed
1209 1210
	rt->rt_flags      = flags;
	if (flags & RTCF_LOCAL)
1211
		rt->dst.input = dn_nsp_rx;
Linus Torvalds's avatar
Linus Torvalds committed
1212 1213 1214 1215 1216

	err = dn_rt_set_next_hop(rt, &res);
	if (err)
		goto e_neighbour;

1217
	hash = dn_hash(rt->fld.saddr, rt->fld.daddr);
Linus Torvalds's avatar
Linus Torvalds committed
1218 1219 1220 1221 1222 1223 1224 1225