device_info.c

mobile ip 在linux下的一种实现

/* $Id: device_info.c,v 1.12 2001/09/08 14:29:40 jm Exp $
 * Device information daemon in a unix domain socket
 *
 * 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.
 */

/*
 * Device info daemon can be used to query device priorities. It uses
 * configuration file by default in /etc/device_info.conf. The file
 * contains MAC addresses of devices and priorities to them. 
 */

#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif

#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <getopt.h>
#include <unistd.h>
#include <signal.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/param.h>
#include <sys/ioctl.h>
#include <linux/if.h>

#include "util.h"
#include "dyn_mnlib.h"
#include "agentapi.h"
#include "fixed_fd_zero.h"
#include "device_info.h"
#include "dyn_ip.h"

#define PID_FILE "/var/run/device_info.pid"
#define MAXLINE 100

static char *default_socket_path = DEFAULT_DEVICE_INFO_PATH;
static char *default_config_file_path = "/etc/device_info.conf";
static char *config_file_path = NULL;
static char *socket_path = NULL;
static fd_set set;
static int debug = 0;

static struct device_info_config *config = NULL;

struct device_info_config {
	unsigned char hw[ETH_ALEN];
	int priority;
	int line;
	struct device_info_config *next;
};


void DEBUG(char *format, ...)
{
	va_list ap;

	if (!debug)
		return;

	va_start(ap, format);
	vfprintf(stdout, format, ap);
	fflush(stdout);
	va_end(ap);
}


static int open_socket(char *path)
{
	if (!path) {
		fprintf(stderr, "open_socket: path is NULL\n");
		return -1;
	}
	return api_open_socket(path, NULL, NULL, (int)0666);
}


static void clean_up(int sig)
{
	unlink(PID_FILE);
	exit(sig);
}


static struct device_info_config *find_entry(char *hw)
{
	struct device_info_config *conf = config;

	if (hw == NULL)
		return NULL;

	while (conf != NULL) {
		if (!memcmp(hw, conf->hw, ETH_ALEN))
			return conf;
		conf = conf->next;
	}

	return NULL;
} 


static int send_reply(int sock, struct sockaddr_un *addr,
		      struct device_info_query *query)
{
	int r;
	if (addr == NULL || query == NULL) {
		fprintf(stderr, "send_reply: NULL argument\n");
		return -1;
	}

	DEBUG("\tsending reply: index = %d, prio %d\n",
	      query->device_index, query->priority);

	r = sendto(sock, query, sizeof(struct device_info_query), 0,
		   (struct sockaddr *)addr, sizeof(struct sockaddr_un));
	if (r != sizeof(struct device_info_query)) {
		fprintf(stderr, "send_reply: sendto %d/%d bytes: %s\n",
			r, sizeof(query), strerror(errno));
		return -1;
	}
	
	return r;
}


static int handle_request(int sock)
{
	struct sockaddr_un addr;
	struct device_info_query query;
	struct device_info_config *config;
	struct idxmap *idxmap, *idx;
	struct ifreq ifr;
	int n, len, found = 0, s;

	len = sizeof(addr);
	n = recvfrom(sock, &query, sizeof(query), 0, (struct sockaddr *) &addr,
		     (unsigned int *)&len);
	if (n != sizeof(query)) {
		fprintf(stderr, "handle_request: couldn't receive whole "
			"message %d/%d\n", n, sizeof(query));
		return -1;
	}
	

	DEBUG("received query\n\tquery.device_index = %d\n", 
	      query.device_index);
	memset(&ifr, 0, sizeof(ifr));

	/* find interface name for the index */
	idxmap = dyn_ip_get_interface_map();
	idx = idxmap;
	while (idx != NULL) {
		if (idx->index == query.device_index) {
			memcpy(ifr.ifr_name, idx->name, sizeof(ifr.ifr_name));
			DEBUG("\tdevice name: %s\n", ifr.ifr_name);
			found = 1;
			break;
		}
		idx = idx->next;
	}
	dyn_ip_free_interface_map(idxmap);
	if (!found) {
		fprintf(stderr, "handle_request: Couldn't find ifname\n");
		return -1;
	}

 	ifr.ifr_ifindex = query.device_index;
	s = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
	if (s < 0) {
		fprintf(stderr, "handle_request: socket failed: %s\n",
		      strerror(errno));
		return -1;
	}
	if (ioctl(s, SIOCGIFHWADDR, &ifr) != 0) {
		fprintf(stderr, "handle_request: SIOCGIFHWADDR ioctl: %s\n",
			strerror(errno));
		return -1;
	}
	config = find_entry(ifr.ifr_hwaddr.sa_data);
	found = 1;
	if (!config) {
		DEBUG("handle_request: entry not found (%s)\n", 
		       ether_hwtoa((unsigned char *)&ifr.ifr_hwaddr.sa_data));
		found = 0;
		query.priority = -2; /* entry not found */
	} else {
		query.priority = config->priority;
		DEBUG("\tquery.priority = %d\n", query.priority);
	}
	
	/* reply */
	n = send_reply(sock, &addr, &query);
	if (n < 0) {
		fprintf(stderr, "handle_request: Couldn't send reply\n");
		return -1;
	}

	return 0;
}


static void parse_config(int sig)
{
	FILE *file;
	char buffer[MAXLINE];
	struct device_info_config *conf = config, *first = config;
	int line = 0, n;
	unsigned int hw[6];


	if (debug && sig == SIGHUP)
		DEBUG("HUP signal received. Rereading config file\n");

	if (config_file_path == NULL) {
		fprintf(stderr, "parse_config: path is NULL\n");
		return;
	}
	file = fopen(config_file_path, "r");
	if (file == NULL) {
		fprintf(stderr, "parse_config: Can't open file %s\n",
			strerror(errno));
		return;
	}
	
	while (fgets(buffer, MAXLINE, file) != NULL) {
		buffer[strlen(buffer)-1]='\0';
		++line;
		if (buffer[0] == '#' || 
		    buffer[0] == '\n' || 
		    buffer[0] == '\t' ||
		    buffer[0] == ' ' ||
		    strlen(buffer) == 0) {
			continue;
		}

		if (conf == NULL) {
			DEBUG("Reading first time the configuration file\n");
			conf = malloc(sizeof(struct device_info_config));
			first = conf;
		}
		else {
			conf->next = malloc(sizeof(struct device_info_config));
			conf = conf->next;
		}
		if (conf == NULL) {
			fprintf(stderr, "parse_config: Memory allocation "
				"failed\n");
			fclose(file);
			return;
		}
		n = sscanf(buffer, "%02x:%02x:%02x:%02x:%02x:%02x %d", 
			   &hw[0], &hw[1], &hw[2], &hw[3], &hw[4], &hw[5], 
			   &conf->priority);
		if (n != 7) {
			fprintf(stderr, "parse_config: Couldn't parse "
				"line %d '%s'\n", line, buffer);
			fclose(file);
			return;
		}
		conf->line = line;
		conf->hw[0] = (unsigned char)hw[0];
		conf->hw[1] = (unsigned char)hw[1];
		conf->hw[2] = (unsigned char)hw[2];
		conf->hw[3] = (unsigned char)hw[3];
		conf->hw[4] = (unsigned char)hw[4];
		conf->hw[5] = (unsigned char)hw[5];
		DEBUG("%s prio %d (line %d)\n", 
		      ether_hwtoa((unsigned char *)conf->hw), 
		      conf->priority, conf->line);
	}

	fclose(file);
	config = first;

	return;
}


int main(int argc, char *argv[])
{
	int s, foreground = 0, c, n;

	socket_path = default_socket_path;
	config_file_path = default_config_file_path;
	while (1) {
		int option_index = 0;
		static struct option long_options[] = {
			{"fg", no_argument, NULL, 'f'},
			{"debug", no_argument, NULL, 'd'},
			{0, 0, 0, 0}
		};
		
		c = getopt_long (argc, argv, "fdc:s:",
				 long_options, &option_index);
		if (c == -1)
			break;
		
		switch (c) {
		case 'f':
			switch (option_index) {
			case 0:
				fprintf(stderr,"Option: %s\n",
				      long_options[option_index].name);
				foreground = 1;
			}
			break;
		case 'c':
			config_file_path = malloc(MAXPATHLEN);
			if (config_file_path == NULL) {
				fprintf(stderr, "malloc for config: %s\n",
					strerror(errno));
				exit(1);
			}
			dynamics_strlcpy(config_file_path, optarg, MAXPATHLEN);
			break;
		case 's':
			socket_path = malloc(MAXPATHLEN);
			if (socket_path == NULL) {
				fprintf(stderr, "malloc for path: %s\n",
					strerror(errno));
				exit(1);
			}
			dynamics_strlcpy(socket_path, optarg, MAXPATHLEN);
			break;
		case 'd':
			debug = 1;
			break;
		case '?':
			fprintf(stderr, "device_info -c <configuration file> "
				"[-s <API socket>] [--fg]\n");
			exit(1);
		default:
			fprintf(stderr, "?? getopt returned character code "
				"0%o ??\n", c);
		}
	}

	parse_config(0);
	if (config == NULL) {
		fprintf(stderr, "Configuration file parsing failed\n");
		exit(1);
	}

	s = open_socket(socket_path);
	if (s < 0) {
		fprintf(stderr, "Open socket failed\n");
		exit(1);
	}

	DEBUG("Initializing mn admin socket path\n");
	c = dynamics_mn_init(NULL);
	if (c == API_FAILED || c == API_ERROR) {
		fprintf(stderr, "MN admin socket path initialization "
			"failed\n");
		exit(1);
	}
	DEBUG("Registering device info socket path\n");

	if (dynamics_mn_register_dev_info_socket(socket_path, 3) 
	    != API_SUCCESS) {
		fprintf(stderr, "API device info socket initialization "
			"failed\n");
		exit(1);
	}
	DEBUG("\tregistered\n");

	if (!foreground && dynamics_fork_daemon() < 0) {
		fprintf(stderr, "fork failed\n");
		exit(1);
	}
	dynamics_write_pid_file(PID_FILE);

	signal(SIGHUP, parse_config);
	signal(SIGTERM, clean_up);
	signal(SIGINT, clean_up);

	for (;;) {
		FD_ZERO(&set);
		FD_SET(s, &set);

		n = select(FD_SETSIZE, &set, NULL, NULL, NULL);
		if (n < 0 && errno != EINTR)
			fprintf(stderr, "select: %s\n",
				strerror(errno));
	  
		if (n == 1 && FD_ISSET(s, &set))
			handle_request(s);
	}

	return 0;
}