mn_handler.c

mobile ip 在linux下的一种实现

/* $id: mn_handler.c,v 1.5 1999/09/21 19:15:08 dforsber Exp $
 * Mobile Node handler module
 *
 * Dynamic hierarchial IP tunnel
 * Copyright (C) 1998-2001, Dynamics group
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation. See README and COPYING for
 * more details.
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#ifdef DYN_TARGET_LINUX
#include <linux/if.h>
#endif

#include "mn_handler.h"
#include "mn.h"
#include "debug.h"
#include "util.h"
#include "device_info.h"
#include "fixed_fd_zero.h"

extern struct mn_data mn;
extern int real_tunnel_up; /* from mn_tunnel */

/* Event hooks. Handler lists */
static struct list fa_adv_rec_handlers;
static struct list fa_adv_exp_handlers;
static struct list fa_get_handlers;
static struct list interface_init_handlers;
static struct list interface_down_handlers;

/* MN default Handlers (called first) */
static int mn_default_FA_GET_handler(void *data);
static int mn_default_INTERFACE_INIT_handler(void *data);
static int mn_default_INTERFACE_DOWN_handler(void *data);


static int get_device_priority(char *ifname)
{
	int i;

	if (ifname == NULL)
		return -1;

	for (i = 0; i < MAX_INTERFACES; i++) {
		if (mn.iface[i].s > -1 && 
		    strncmp(mn.iface[i].device, ifname, IFNAMSIZ) == 0) {
			DEBUG(DEBUG_HANDLERS, "\tdevice %s", 
			      mn.iface[i].device);
			return mn.iface[i].priority;
		}
	}

	DEBUG(DEBUG_HANDLERS, "get_device_priority: Couldn't find interface "
	      "from interface list (%s, device count %d)\n", ifname, 
	      mn.device_count);
	return -1;
}


/* This function will honor the force FA address. If the force FA flag is
 * set only one advertisement entry has priority 1 and that's the force FA's
 * advertisement. */
static int set_base_priority(struct node *node, void *data)
{
	struct timeval tval = *((struct timeval *)data);
	struct agentadv_data *adv = (struct agentadv_data *) node;
	int prio, i;

	DEBUG(DEBUG_HANDLERS, "set_base_priority: %-15s ", 
	      inet_ntoa(adv->addr));

	i = cmp_timeval(&tval, &adv->expire);
	if (i >= 0)
		DEBUG(DEBUG_HANDLERS, " EXPIRED");
	if ((i < 0 || mn.force_fa_addr.s_addr != 0) && adv_ok_fa(adv)) {
		if (mn.force_fa_addr.s_addr != 0)
			DEBUG(DEBUG_HANDLERS, " FORCED FA");
		prio = get_device_priority(adv->ifname);
		if (prio > 0)
			adv->priority = prio;
		DEBUG(DEBUG_HANDLERS, " prio: %d", adv->priority);
	} else
		adv->priority = 0;

	DEBUG(DEBUG_HANDLERS, "\n");
	return TRUE;
}


static int mn_default_FA_GET_handler(void *data)
{
	struct timeval tval;
	struct hashtable *hash;

	if (data == NULL)
		return -1;

	hash = ((struct event_FA *)data)->hash;

	if (hash == NULL) {
		DEBUG(DEBUG_HANDLERS, "mn_default_FA_GET_handler: hashtable "
		      "pointer was NULL\n");
		return 0;
	}

	gettimeofday(&tval, NULL);
	hashtable_iterator(hash, set_base_priority, &tval);

	return 0;
}


static int open_query_socket(void)
{
	int sock, r;
	struct sockaddr_un addr;
	socklen_t addrlen;
	
	sock = socket(AF_LOCAL, SOCK_DGRAM, 0);
	if (sock < 0)
		return sock;
	
	memset(&addr, 0, sizeof(struct sockaddr_un));
	addr.sun_family = AF_LOCAL;
	addr.sun_path[0] = '\0';
	snprintf(addr.sun_path + 1, sizeof(addr.sun_path) - 1,
		 "dynamics-%i-%i", getpid(), (int) random());
	addrlen = sizeof(addr.sun_family) + 1 + strlen(addr.sun_path + 1);
	
	r = bind(sock, (struct sockaddr *) &addr, addrlen);
	if (r < 0) {
		DEBUG(DEBUG_INFO, "open_query_socket: bind failed: %s\n",
		      strerror(errno));
		return -1;
	}

	return sock;
}


static int mn_get_device_priority(int index)
{
	struct device_info_query msg;
	int s;
	fd_set set;
	int n;
	struct timeval tv;

	msg.device_index = index;
	msg.priority = -1;

	/* open socket */
	s = open_query_socket();
	if (s < 0) {
		DEBUG(DEBUG_HANDLERS, "mn_get_device_priority: socket: %s",
		      strerror(errno));
		return s;
	}

	/* send query */
	n = sendto(s, &msg, sizeof(struct device_info_query), 0, 
		   (struct sockaddr *)&mn.dev_info_addr, 
		   sizeof(mn.dev_info_addr));
	if (n != sizeof(struct device_info_query)) {
		DEBUG(DEBUG_HANDLERS, "\tmn_get_device_priority: sendto "
		      "%d/%d bytes: %s\n", n, 
		      sizeof(struct device_info_query), strerror(errno));
		close(s);
		return -1;
	}

	/* get reply */
	FD_ZERO(&set);
	FD_SET(s, &set);
	tv.tv_usec = MICRO_SECONDS_TO_WAIT_INFO_REPLY;
	tv.tv_sec = 0;
	n = select(FD_SETSIZE, &set, NULL, NULL, &tv);
	if (n != 1 || !FD_ISSET(s, &set)) {
		DEBUG(DEBUG_HANDLERS, "mn_get_device_priority: no device "
		      "info daemon present?\n");
		close(s);
		return -1;
	}

	n = recvfrom(s, (void *) &msg, sizeof(msg), 0, NULL, 0);
	if (n != sizeof(msg)) {
		DEBUG(DEBUG_HANDLERS, "mn_get_device_priority: couldn't "
		      "receive the whole message %d/%d\n", 
			n, sizeof(msg));
		close(s);
		return -1;
	}
	DEBUG(DEBUG_HANDLERS, "mn_get_device_priority: received reply. "
	      "priority = %d\n", msg.priority);

	close(s);
	return msg.priority;
}


static int mn_default_INTERFACE_INIT_handler(void *data)
{
	struct event_INTERFACE *i = (struct event_INTERFACE *)data;
	int prio;
	
	if (!i)
		return -1;
	
	DEBUG(DEBUG_HANDLERS, "mn_default_INTERFACE_INIT_handler\n");
	DEBUG(DEBUG_HANDLERS, "\tOpening ICMP socket for interface "
	      "%s (index=%i).\n", i->idx->name, i->idx->index);
	*(i->icmp_sock_adv) = open_agent_icmp_adv_socket(i->idx->name,
							 AGENTADV_FILTER_ADV);
	if (*(i->icmp_sock_adv) < 0) {
		DEBUG(DEBUG_HANDLERS,
		      "\tOpening ICMP adv. socket failed: %s. "
		      "Ignoring this interface.\n",
		      strerror(errno));
		return -1;
	}
	*(i->icmp_sock) = open_agent_icmp_socket(i->idx->name, ICMP_FILTER_MN);
	if (*(i->icmp_sock) < 0) {
		DEBUG(DEBUG_HANDLERS, "\tOpening ICMP socket failed: %s."
		      " Ignoring this interface.\n",
		      strerror(errno));
		close(*(i->icmp_sock_adv));
		*(i->icmp_sock_adv) = -1;
		return -1;
	}
	DEBUG(DEBUG_HANDLERS, "sockets: sol=%i adv=%i\n",
	      *i->icmp_sock, *i->icmp_sock_adv);
	
	*(i->index) = i->idx->index;
	DEBUG(DEBUG_HANDLERS, "\tindex = %d\n", i->idx->index);
	memcpy(i->ifname, i->idx->name, IFNAMSIZ);

	/* set priority for the device */
	if (i->priority == NULL) {
		DEBUG(DEBUG_HANDLERS, "\tpriority pointers is NULL!\n");
		return -1;
	}
	*(i->priority) = DEFAULT_INTERFACE_PRIORITY;
	prio = mn_get_device_priority(i->idx->index);
	if (prio > 0) {
		DEBUG(DEBUG_HANDLERS, "\tGot priority from interface info "
		      "daemon: %d\n", prio);
		*(i->priority) = prio;
	}
	DEBUG(DEBUG_HANDLERS, "\tinterface priority = %d\n", *(i->priority));

	/* send agent solicitation */
	send_agent_solicitation(*(i->icmp_sock));
	if (i->iface != NULL)
		gettimeofday(&i->iface->last_solicitation, NULL);

	return 0;
}


static int remove_agentadv_data(struct node *node, void *data)
{
	struct agentadv_data *adv;
	int *ifindex;

	adv = (struct agentadv_data *) node;
	ifindex = (int*) data;
	if (*ifindex == adv->ifindex) {
		DEBUG(DEBUG_AGENTADV, "\tremoving agentadv item: %s (%s)\n",
		      inet_ntoa(adv->addr), adv->ifname);
		clean_agentadv(node, NULL);
	}
	
	return TRUE;
}


static int mn_default_INTERFACE_DOWN_handler(void *data)
{
	struct event_INTERFACE *i = (struct event_INTERFACE *)data;

	if(!i)
		return -1;

	/* close sockets */
	DEBUG(DEBUG_HANDLERS,
	      "Closing ICMP socket for interface %s (index=%d)\n",
	      i->ifname, *(i->index));
	close(*(i->icmp_sock));
	*(i->icmp_sock) = -1;
	if (*(i->icmp_sock_adv) > -1)
		close(*(i->icmp_sock_adv));
	*(i->icmp_sock_adv) = -1;

	if (mn.current_adv != NULL && *(i->index) == mn.current_adv->ifindex) {
		DEBUG(DEBUG_HANDLERS, "Current interface down - resetting "
		      "connections\n");
		mn.tunnel_addr.s_addr = 0;
		real_tunnel_up = 0;
	}

	/* clear saved agent advertisement entries that came from 
	   this interface */
	DEBUG(DEBUG_AGENTADV, "Clearing agentadv cache for interface: %s "
	      "(index=%i)\n", i->ifname, *(i->index));
	hashtable_iterator(mn.agentadv, remove_agentadv_data, i->index);

	return 0;
}


/* Initialize all handler lists. Called once, when first handler is added. */
static void init_handler_lists(void)
{
	DEBUG(DEBUG_HANDLERS, "init_handler_lists: begin\n");
	list_init(&fa_adv_rec_handlers);     /* FA_ADV_EXPIRE  */
	list_init(&fa_adv_exp_handlers);     /* FA_ADV_RECEIVE */
	list_init(&fa_get_handlers);         /* FA_GET         */
	list_init(&interface_init_handlers); /* INTERFACE_INIT */
	list_init(&interface_down_handlers); /* INTERFACE_DOWN */
	DEBUG(DEBUG_HANDLERS, "init_handler_lists: end\n");
}


/* Register handler to the <event_type> list */
int handler_register(int event_type, int (*func)(void *data))
{
	static int inited = 0;
	struct handler *new;

	/* Init all lists for now */
	if (!inited) {
		init_handler_lists();
		inited = 1;
	}

	new = calloc(1, sizeof(struct handler));
	if (new == NULL) {
		DEBUG(DEBUG_HANDLERS, "handler_register: calloc: %s",
		      strerror(errno));
		return 1;
	}

	list_init_node(&new->listnode);
	new->func = func;

	switch (event_type) {
	case FA_ADV_RECEIVE:
		list_add_tail(&fa_adv_rec_handlers, &new->listnode);
		break;
	case FA_ADV_EXPIRE:
		list_add_tail(&fa_adv_exp_handlers, &new->listnode);
		break;
	case FA_GET:
		list_add_tail(&fa_get_handlers, &new->listnode);
		break;
	case INTERFACE_INIT:
		list_add_tail(&interface_init_handlers, &new->listnode);
		break;
	case INTERFACE_DOWN:
		list_add_tail(&interface_down_handlers, &new->listnode);
		break;
	default:
		DEBUG(DEBUG_HANDLERS, "handler_register: Unknown event "
		      "type (%d)\n", event_type);
		return 2;
	}

	DEBUG(DEBUG_HANDLERS, "handler_register: \"%s\" Event handler "
	      "registered\n", event_type_str(event_type));

	return 0;
}


/* Unregister handler from the <event_type> list
 * return:
 *  0 success
 *  -1 list is empty or no such handler
 *  -2 no such event type
 */
int handler_unregister(int event_type, int (*func)(void *data))
{
	struct list *handlers;
	struct node *iterator;
	struct handler *p;

	switch (event_type) {
	case FA_ADV_RECEIVE:
		handlers = &fa_adv_rec_handlers;
		break;
	case FA_ADV_EXPIRE:
		handlers = &fa_adv_exp_handlers;
		break;
	case FA_GET:
		handlers = &fa_get_handlers;
		break;
	case INTERFACE_INIT:
		handlers = &interface_init_handlers;
		break;
	case INTERFACE_DOWN:
		handlers = &interface_down_handlers;
		break;
	default:
		DEBUG(DEBUG_HANDLERS, "handler_unregister: Unknown event type "
		      "(%d)\n", event_type);
		return -2;
	}

	iterator = list_get_first(handlers);
	while (iterator != NULL) {
		p = (struct handler *) iterator;
		if (p->func == func) {
			list_remove(iterator);
			DEBUG(DEBUG_HANDLERS, "handler_unregister: "
			      "\"%s\" Event handler unregistered\n",
			      event_type_str(event_type));
			free(p);
			return 0;
		}
		iterator = list_get_next(iterator);
	}

	/* List is empty or no such handler found */
	return -1;
}


/* Remove all hooked handlers for this <event_type> */
int handler_unregister_all(int event_type)
{
	struct node *iterator;
	struct list *handlers;
	struct handler *p;
	int i = 0, r;

	switch (event_type) {
	case FA_ADV_RECEIVE:
		handlers = &fa_adv_rec_handlers;
		break;
	case FA_ADV_EXPIRE:
		handlers = &fa_adv_exp_handlers;
		break;
	case FA_GET:
		handlers = &fa_get_handlers;
		break;
	case INTERFACE_INIT:
		handlers = &interface_init_handlers;
		break;
	case INTERFACE_DOWN:
		handlers = &interface_down_handlers;
		break;
	default:
		DEBUG(DEBUG_HANDLERS, "handler_unregister_all: Unknown event "
		      "type (%d)\n", event_type);
		return -2;
	}

	iterator = list_get_first(handlers);
	while (iterator != NULL) {
		p = (struct handler *) iterator;
		iterator = list_get_next(iterator);
		r = handler_unregister(event_type, p->func);
		if (!r)
			i++;
	}

	return i;
}


/* Call all hooked handlers for this <event_type> */
int handler_call_all(int event_type, void *data)
{
	struct list *handlers;
	struct node *iterator;
	struct handler *p;
	int num = 0;
	int ret = 0;

	switch (event_type) {
	case FA_ADV_RECEIVE:
		handlers = &fa_adv_rec_handlers;
		break;
	case FA_ADV_EXPIRE:
		handlers = &fa_adv_exp_handlers;
		break;
	case FA_GET:
		handlers = &fa_get_handlers;
		break;
	case INTERFACE_INIT:
		handlers = &interface_init_handlers;
		break;
	case INTERFACE_DOWN:
		handlers = &interface_down_handlers;
		break;
	default:
		DEBUG(DEBUG_HANDLERS, "handler_call_all: Unknown event "
		      "type (%d)", event_type);
		return 2;
	}

	iterator = list_get_first(handlers);
	while (iterator != NULL) {
		p = (struct handler *) iterator;
		if (p->func != NULL) {
			ret = (*p->func)(data);
			num++;
			if (ret == -1) {
				DEBUG(DEBUG_HANDLERS, "handler_call_all: "
				      "handler returned -1. %d handlers "
				      "called\n", num);
				return -1;
			}
		}
		iterator = list_get_next(iterator);
	}

	DEBUG(DEBUG_HANDLERS, "handler_call_all: %d \"%s\" Event "
	      "handlers called\n", num, event_type_str(event_type));

	return 0;
}


int mn_handlers_init(void)
{
	/* Register the MN default handler for FA selection (for now
	 * must be the first one in the handler list) */
	DEBUG(DEBUG_HANDLERS, "Register MN default FA_GET handler\n");
	handler_register(FA_GET, mn_default_FA_GET_handler);
	
	/* Register the MN default handler for interface initialization */
	DEBUG(DEBUG_HANDLERS, "Register MN default INTERFACE_INIT handler\n");
	handler_register(INTERFACE_INIT, mn_default_INTERFACE_INIT_handler);
	
	/* Register the MN default handler for interface down event */
	DEBUG(DEBUG_HANDLERS, "Register MN default INTERFACE_DOWN handler\n");
	handler_register(INTERFACE_DOWN, mn_default_INTERFACE_DOWN_handler);
	
	return 0;
}