nr_route.c

Linux内核源代码 为压缩文件 是<<Linux内核>>一书中的源代码

/*
 *	NET/ROM release 007
 *
 *	This code REQUIRES 2.1.15 or higher/ NET3.038
 *
 *	This module:
 *		This module 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 (at your option) any later version.
 *
 *	History
 *	NET/ROM 001	Jonathan(G4KLX)	First attempt.
 *	NET/ROM	003	Jonathan(G4KLX)	Use SIOCADDRT/SIOCDELRT ioctl values
 *					for NET/ROM routes.
 *					Use '*' for a blank mnemonic in /proc/net/nr_nodes.
 *					Change default quality for new neighbour when same
 *					as node callsign.
 *			Alan Cox(GW4PTS) Added the firewall hooks.
 *	NET/ROM 006	Jonathan(G4KLX)	Added the setting of digipeated neighbours.
 *			Tomi(OH2BNS)	Routing quality and link failure changes.
 */

#include <linux/errno.h>
#include <linux/types.h>
#include <linux/socket.h>
#include <linux/in.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/timer.h>
#include <linux/string.h>
#include <linux/sockios.h>
#include <linux/net.h>
#include <net/ax25.h>
#include <linux/inet.h>
#include <linux/netdevice.h>
#include <net/arp.h>
#include <linux/if_arp.h>
#include <linux/skbuff.h>
#include <net/sock.h>
#include <asm/uaccess.h>
#include <asm/system.h>
#include <linux/fcntl.h>
#include <linux/termios.h>	/* For TIOCINQ/OUTQ */
#include <linux/mm.h>
#include <linux/interrupt.h>
#include <linux/notifier.h>
#include <linux/netfilter.h>
#include <linux/init.h>
#include <net/netrom.h>

static unsigned int nr_neigh_no = 1;

static struct nr_node  *nr_node_list;
static struct nr_neigh *nr_neigh_list;

static void nr_remove_neigh(struct nr_neigh *);

/*
 *	Add a new route to a node, and in the process add the node and the
 *	neighbour if it is new.
 */
static int nr_add_node(ax25_address *nr, const char *mnemonic, ax25_address *ax25,
	ax25_digi *ax25_digi, struct net_device *dev, int quality, int obs_count)
{
	struct nr_node  *nr_node;
	struct nr_neigh *nr_neigh;
	struct nr_route nr_route;
	unsigned long flags;
	int i, found;

	if (nr_dev_get(nr) != NULL)	/* Can't add routes to ourself */
		return -EINVAL;

	for (nr_node = nr_node_list; nr_node != NULL; nr_node = nr_node->next)
		if (ax25cmp(nr, &nr_node->callsign) == 0)
			break;

	for (nr_neigh = nr_neigh_list; nr_neigh != NULL; nr_neigh = nr_neigh->next)
		if (ax25cmp(ax25, &nr_neigh->callsign) == 0 && nr_neigh->dev == dev)
			break;

	/*
	 * The L2 link to a neighbour has failed in the past
	 * and now a frame comes from this neighbour. We assume
	 * it was a temporary trouble with the link and reset the
	 * routes now (and not wait for a node broadcast).
	 */
	if (nr_neigh != NULL && nr_neigh->failed != 0 && quality == 0) {
		struct nr_node *node;

		for (node = nr_node_list; node != NULL; node = node->next)
			for (i = 0; i < node->count; i++)
				if (node->routes[i].neighbour == nr_neigh)
					if (i < node->which)
						node->which = i;
	}

	if (nr_neigh != NULL)
		nr_neigh->failed = 0;

	if (quality == 0 && nr_neigh != NULL && nr_node != NULL)
		return 0;

	if (nr_neigh == NULL) {
		if ((nr_neigh = kmalloc(sizeof(*nr_neigh), GFP_ATOMIC)) == NULL)
			return -ENOMEM;

		nr_neigh->callsign = *ax25;
		nr_neigh->digipeat = NULL;
		nr_neigh->ax25     = NULL;
		nr_neigh->dev      = dev;
		nr_neigh->quality  = sysctl_netrom_default_path_quality;
		nr_neigh->locked   = 0;
		nr_neigh->count    = 0;
		nr_neigh->number   = nr_neigh_no++;
		nr_neigh->failed   = 0;

		if (ax25_digi != NULL && ax25_digi->ndigi > 0) {
			if ((nr_neigh->digipeat = kmalloc(sizeof(*ax25_digi), GFP_KERNEL)) == NULL) {
				kfree(nr_neigh);
				return -ENOMEM;
			}
			memcpy(nr_neigh->digipeat, ax25_digi, sizeof(ax25_digi));
		}

		save_flags(flags);
		cli();

		nr_neigh->next = nr_neigh_list;
		nr_neigh_list  = nr_neigh;

		restore_flags(flags);
	}

	if (quality != 0 && ax25cmp(nr, ax25) == 0 && !nr_neigh->locked)
		nr_neigh->quality = quality;

	if (nr_node == NULL) {
		if ((nr_node = kmalloc(sizeof(*nr_node), GFP_ATOMIC)) == NULL)
			return -ENOMEM;

		nr_node->callsign = *nr;
		strcpy(nr_node->mnemonic, mnemonic);

		nr_node->which = 0;
		nr_node->count = 1;

		nr_node->routes[0].quality   = quality;
		nr_node->routes[0].obs_count = obs_count;
		nr_node->routes[0].neighbour = nr_neigh;

		save_flags(flags);
		cli();

		nr_node->next = nr_node_list;
		nr_node_list  = nr_node;

		restore_flags(flags);

		nr_neigh->count++;

		return 0;
	}

	if (quality != 0)
		strcpy(nr_node->mnemonic, mnemonic);

	for (found = 0, i = 0; i < nr_node->count; i++) {
		if (nr_node->routes[i].neighbour == nr_neigh) {
			nr_node->routes[i].quality   = quality;
			nr_node->routes[i].obs_count = obs_count;
			found = 1;
			break;
		}
	}

	if (!found) {
		/* We have space at the bottom, slot it in */
		if (nr_node->count < 3) {
			nr_node->routes[2] = nr_node->routes[1];
			nr_node->routes[1] = nr_node->routes[0];

			nr_node->routes[0].quality   = quality;
			nr_node->routes[0].obs_count = obs_count;
			nr_node->routes[0].neighbour = nr_neigh;

			nr_node->which++;
			nr_node->count++;
			nr_neigh->count++;
		} else {
			/* It must be better than the worst */
			if (quality > nr_node->routes[2].quality) {
				nr_node->routes[2].neighbour->count--;

				if (nr_node->routes[2].neighbour->count == 0 && !nr_node->routes[2].neighbour->locked)
					nr_remove_neigh(nr_node->routes[2].neighbour);

				nr_node->routes[2].quality   = quality;
				nr_node->routes[2].obs_count = obs_count;
				nr_node->routes[2].neighbour = nr_neigh;

				nr_neigh->count++;
			}
		}
	}

	/* Now re-sort the routes in quality order */
	switch (nr_node->count) {
		case 3:
			if (nr_node->routes[1].quality > nr_node->routes[0].quality) {
				switch (nr_node->which) {
					case 0:  nr_node->which = 1; break;
					case 1:  nr_node->which = 0; break;
					default: break;
				}
				nr_route           = nr_node->routes[0];
				nr_node->routes[0] = nr_node->routes[1];
				nr_node->routes[1] = nr_route;
			}
			if (nr_node->routes[2].quality > nr_node->routes[1].quality) {
				switch (nr_node->which) {
					case 1:  nr_node->which = 2; break;
					case 2:  nr_node->which = 1; break;
					default: break;
				}
				nr_route           = nr_node->routes[1];
				nr_node->routes[1] = nr_node->routes[2];
				nr_node->routes[2] = nr_route;
			}
		case 2:
			if (nr_node->routes[1].quality > nr_node->routes[0].quality) {
				switch (nr_node->which) {
					case 0:  nr_node->which = 1; break;
					case 1:  nr_node->which = 0; break;
					default: break;
				}
				nr_route           = nr_node->routes[0];
				nr_node->routes[0] = nr_node->routes[1];
				nr_node->routes[1] = nr_route;
			}
		case 1:
			break;
	}

	for (i = 0; i < nr_node->count; i++) {
		if (nr_node->routes[i].neighbour == nr_neigh) {
			if (i < nr_node->which)
				nr_node->which = i;
			break;
		}
	}

	return 0;
}

static void nr_remove_node(struct nr_node *nr_node)
{
	struct nr_node *s;
	unsigned long flags;

	save_flags(flags);
	cli();

	if ((s = nr_node_list) == nr_node) {
		nr_node_list = nr_node->next;
		restore_flags(flags);
		kfree(nr_node);
		return;
	}

	while (s != NULL && s->next != NULL) {
		if (s->next == nr_node) {
			s->next = nr_node->next;
			restore_flags(flags);
			kfree(nr_node);
			return;
		}

		s = s->next;
	}

	restore_flags(flags);
}

static void nr_remove_neigh(struct nr_neigh *nr_neigh)
{
	struct nr_neigh *s;
	unsigned long flags;
	
	save_flags(flags);
	cli();

	if ((s = nr_neigh_list) == nr_neigh) {
		nr_neigh_list = nr_neigh->next;
		restore_flags(flags);
		if (nr_neigh->digipeat != NULL)
			kfree(nr_neigh->digipeat);
		kfree(nr_neigh);
		return;
	}

	while (s != NULL && s->next != NULL) {
		if (s->next == nr_neigh) {
			s->next = nr_neigh->next;
			restore_flags(flags);
			if (nr_neigh->digipeat != NULL)
				kfree(nr_neigh->digipeat);
			kfree(nr_neigh);
			return;
		}

		s = s->next;
	}

	restore_flags(flags);
}

/*
 *	"Delete" a node. Strictly speaking remove a route to a node. The node
 *	is only deleted if no routes are left to it.
 */
static int nr_del_node(ax25_address *callsign, ax25_address *neighbour, struct net_device *dev)
{
	struct nr_node  *nr_node;
	struct nr_neigh *nr_neigh;
	int i;

	for (nr_node = nr_node_list; nr_node != NULL; nr_node = nr_node->next)
		if (ax25cmp(callsign, &nr_node->callsign) == 0)
			break;

	if (nr_node == NULL) return -EINVAL;

	for (nr_neigh = nr_neigh_list; nr_neigh != NULL; nr_neigh = nr_neigh->next)
		if (ax25cmp(neighbour, &nr_neigh->callsign) == 0 && nr_neigh->dev == dev)
			break;

	if (nr_neigh == NULL) return -EINVAL;

	for (i = 0; i < nr_node->count; i++) {
		if (nr_node->routes[i].neighbour == nr_neigh) {
			nr_neigh->count--;

			if (nr_neigh->count == 0 && !nr_neigh->locked)
				nr_remove_neigh(nr_neigh);

			nr_node->count--;

			if (nr_node->count == 0) {
				nr_remove_node(nr_node);
			} else {
				switch (i) {
					case 0:
						nr_node->routes[0] = nr_node->routes[1];
					case 1:
						nr_node->routes[1] = nr_node->routes[2];
					case 2:
						break;
				}
			}

			return 0;
		}
	}

	return -EINVAL;
}

/*
 *	Lock a neighbour with a quality.
 */
static int nr_add_neigh(ax25_address *callsign, ax25_digi *ax25_digi, struct net_device *dev, unsigned int quality)
{
	struct nr_neigh *nr_neigh;
	unsigned long flags;

	for (nr_neigh = nr_neigh_list; nr_neigh != NULL; nr_neigh = nr_neigh->next) {
		if (ax25cmp(callsign, &nr_neigh->callsign) == 0 && nr_neigh->dev == dev) {
			nr_neigh->quality = quality;
			nr_neigh->locked  = 1;
			return 0;
		}
	}

	if ((nr_neigh = kmalloc(sizeof(*nr_neigh), GFP_ATOMIC)) == NULL)
		return -ENOMEM;

	nr_neigh->callsign = *callsign;
	nr_neigh->digipeat = NULL;
	nr_neigh->ax25     = NULL;
	nr_neigh->dev      = dev;
	nr_neigh->quality  = quality;
	nr_neigh->locked   = 1;
	nr_neigh->count    = 0;
	nr_neigh->number   = nr_neigh_no++;
	nr_neigh->failed   = 0;

	if (ax25_digi != NULL && ax25_digi->ndigi > 0) {
		if ((nr_neigh->digipeat = kmalloc(sizeof(*ax25_digi), GFP_KERNEL)) == NULL) {
			kfree(nr_neigh);
			return -ENOMEM;
		}
		memcpy(nr_neigh->digipeat, ax25_digi, sizeof(ax25_digi));
	}

	save_flags(flags);
	cli();

	nr_neigh->next = nr_neigh_list;
	nr_neigh_list  = nr_neigh;

	restore_flags(flags);

	return 0;	
}

/*
 *	"Delete" a neighbour. The neighbour is only removed if the number
 *	of nodes that may use it is zero.
 */
static int nr_del_neigh(ax25_address *callsign, struct net_device *dev, unsigned int quality)
{
	struct nr_neigh *nr_neigh;

	for (nr_neigh = nr_neigh_list; nr_neigh != NULL; nr_neigh = nr_neigh->next)
		if (ax25cmp(callsign, &nr_neigh->callsign) == 0 && nr_neigh->dev == dev)
			break;

	if (nr_neigh == NULL) return -EINVAL;

	nr_neigh->quality = quality;
	nr_neigh->locked  = 0;

	if (nr_neigh->count == 0)
		nr_remove_neigh(nr_neigh);