fa_tool.c

mobile ip 在linux下的一种实现

/* $Id: fa_tool.c,v 1.27 2001/07/11 15:12:45 jm Exp $
 * Foreign Agent Configuration Tool implemetation file
 *
 * 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 <stdio.h>
#include <stdlib.h>
#ifndef __USE_BSD
#define __USE_BSD
#endif
#include <string.h>
#include <time.h>
#include <assert.h>

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include "dyn_falib.h"
#include "support_tool.h"
#include "util.h"
#include "message.h"

#define ASSERT assert

#define PATH_SIZE  100

#define DEFAULT_PATH SOCKETDIR "/dynamics_fa_admin"

#define MAX_TUNNELS 64

#define HELP_STATUS "Usage\n\tstatus [interval]\n" \
"Description\n\tRetrieve agents status information.\n"\
"\tIf interval is specified, command is run in monitoring mode and "\
"interval specifies time between successive calls in seconds."\
"To stop monitoring press CTRL-C.\n"

#define HELP_LIST "Usage\n\tlist\n" \
"Description\n\tList active tunnel ids in format 'MN addr' 'HA addr'.\n"
#define HELP_SHOW "Usage\n\tshow <MN addr> [HA addr] [priv HA ID]\n" \
"Description\n\tShow information about a tunnel specified with id.\n"
#define HELP_DESTROY "Usage\n\tdestroy <MN addr> [HA addr]\n" \
"Description\n\tDestroy tunnel with specified id.\n"
#define HELP_PATH "Usage\n\tpath <api path>\n"\
"Description\n\tSet path to agent interface socket.\n"\
"Example: path /etc/dynamics_fa_admin\n"
#define HELP_ATTACH "Usage\n\tattach <info socket file>\n"
#define HELP_DETACH "Usage\n\tdetach <info socket file>\n"

void cmd_getstatus(int argc, char *argv[]);
void cmd_list(int argc, char *argv[]);
void cmd_show(int argc, char *argv[]);
void cmd_destroy(int argc, char *argv[]);
void cmd_path(int argc, char *argv[]);
void cmd_attach(int argc, char *argv[]);
void cmd_detach(int argc, char *argv[]);

extern int interactive;

int main(int argc, char *argv[])
{
	int i;
	char agent_path[PATH_SIZE];

	dynamics_strlcpy(agent_path, DEFAULT_PATH, PATH_SIZE);

	tool_add_command("list", 1, cmd_list, HELP_LIST, NULL);
	tool_add_command("show", 1, cmd_show, HELP_SHOW, NULL);
	tool_add_command("destroy", 1, cmd_destroy, HELP_DESTROY, NULL);
	tool_add_command("status", 2, cmd_getstatus, HELP_STATUS, NULL);
	tool_add_command("path", 4, cmd_path, HELP_PATH, NULL);
	tool_add_command("attach", 5, cmd_attach, HELP_ATTACH, NULL);
	tool_add_command("detach", 6, cmd_detach, HELP_DETACH, NULL);

	i = parse_long_options_tools(argc, argv,
				     "Dynamics Foreign Agent Control Tool",
				     agent_path, PATH_SIZE,
				     PACKAGE, VERSION);

	if (interactive) {
		printf("Dynamics Foreign Agent Control Tool v%s\n", VERSION);
		printf("Using agent path \"%s\" \n", agent_path);
	}
	dynamics_fa_init(agent_path);

	return tool_main(argc - i, argv + i);
}

/***********************************************************************
 *              COMMAND HANDLERS                                       *
 * These functions are callback functions, which tool_main calls       *
 * when user executes a command. Commands arguments are passed         *
 * in parameters. argc specifies count of arguments and argv is pointer*
 * to string array containing the actual argument strings.             *
 * first argument is always commands invocation. It may be an          *
 * abbreviation.                                                       *
 ***********************************************************************/

void cmd_getstatus(int argc, char *argv[])
{
	int r;
	struct dynamics_fa_status status;

	if (argc == 2 && (r = atoi(argv[1])) > 0) {
		tool_monitor(argv[0], r);
	}

	r = dynamics_fa_get_status(&status, -1);
	if (r == API_SUCCESS) {
		if (interactive)
			printf("Foreign Agent status:\n");
		printf("version            %s\n", status.version);
		printf("tunnels            %d\n", status.tunnel_count);
		printf("pending reg.req.   %d\n", status.pending_count);
		printf("request rejected   %li\n", status.req_rejected);
		printf("request accepted   %li\n", status.req_accepted);
		printf("reply rejected     %li\n", status.rep_rejected);
		printf("reply accepted     %li\n", status.rep_accepted);
		printf("discard(unk. ext)  %li\n",
		       status.discarded_unknown_ext);
		printf("discard(malformed) %li\n",
		       status.discarded_malformed_msg);
		printf("discard(vendor)    %li\n",
		       status.discarded_vendor_ext);
		printf("advertisement sent %li\n", status.adv_sent);
		printf("apicalls(admin)    %li\n", status.apicalls_admin);
		printf("apicalls(read)     %li\n", status.apicalls_read);
	} else {
		printf("Call failed: %s\n", dynamics_fa_get_error_string(r));
	}
}

void cmd_list(int argc, char *argv[])
{
	int r, c;
	dyn_tunnel_id data[MAX_TUNNELS];

	c = MAX_TUNNELS;
	r = dynamics_fa_get_tunnels(&c, data, -1);
	if (r == API_SUCCESS) {
		if (interactive)
			printf("%d tunnels:\n", c);
		for (r = 0; r < c; r++) {
			printf("%s", inet_ntoa(data[r].mn_addr));
			printf(" %s %i\n", inet_ntoa(data[r].ha_addr),
			       data[r].priv_ha);
		}
		printf("\n");
	} else {
		printf("Call failed: %s\n",
		       dynamics_fa_get_error_string(r));
	}
}

void cmd_destroy(int argc, char *argv[])
{
	int r;
	dyn_tunnel_id id;

	if (argc != 2 && argc != 3) {
		printf("Invalid arguments. Usage 'destroy <MN addr> "
		       "[HA addr]'.\n");
		return;
	}
	if (inet_aton(argv[1], &id.mn_addr) == 0) {
		printf("Invalid <MN addr> argument\n");
		return;
	}
	if (argc > 2) {
		if (inet_aton(argv[2], &id.ha_addr) == 0) {
			printf("Invalid [HA addr] argument\n");
			return;
		}
	} else
		id.ha_addr.s_addr = 0;

	r = dynamics_fa_destroy_tunnel(id, -1);
	if (r == API_SUCCESS) {
		printf("Destroyed tunnel MN=%s", inet_ntoa(id.mn_addr));
		if (id.ha_addr.s_addr != 0)
			printf(" HA=%s.\n", inet_ntoa(id.ha_addr));
		else
			printf(".\n");
	} else {
		printf("Call failed: %s\n", dynamics_fa_get_error_string(r));
	}
}

void cmd_show(int argc, char *argv[])
{
	int r, sz;
	struct dynamics_tunnel_info info;
	dyn_tunnel_id id;
	time_t id_time;

	memset(&id, 0, sizeof(id));
	if (argc != 2 && argc != 3 && argc != 4) {
		printf("Invalid arguments. Usage 'show <MN addr> "
		       "[HA addr] [priv HA ID]'.\n");
		return;
	}

	if (inet_aton(argv[1], &id.mn_addr) == 0) {
		printf("Invalid <MN addr> argument\n");
		return;
	}
	if (argc > 2 && inet_aton(argv[2], &id.ha_addr) == 0) {
		printf("Invalid [HA addr] argument\n");
		return;
	}
	if (argc > 3)
		id.priv_ha = atoi(argv[3]);

	sz = sizeof(info);

	r = dynamics_fa_get_tunnel_info(id, &info, &sz, -1);
	if (r == API_SUCCESS && sz == sizeof(info)) {
		if (interactive) {
			printf("Information about tunnel MN=%s",
			       inet_ntoa(info.id.mn_addr));
			if (info.id.ha_addr.s_addr != 0)
				printf(" HA=%s:\n",
				       inet_ntoa(info.id.ha_addr));
			else
				printf(":\n");
		}
		printf("mobile addr\t%s\n", inet_ntoa(info.mn_addr));
		printf("care-of addr\t%s\n", inet_ntoa(info.co_addr));
		printf("home agent addr\t%s\n", inet_ntoa(info.ha_addr));
		printf("private HA id\t%d\n", info.priv_ha);
		printf("creation time\t%s", ctime(&info.creation_time));
		printf("expiration time\t%s", ctime(&info.expiration_time));
		printf("refresh time\t%s", ctime(&info.refresh_time));
		id_time = info.last_timestamp[0] - UNIX_NTP_DIFF;
		printf("last timestamp\t%ssecond ID\t%d\n",
		       ctime(&id_time), info.last_timestamp[1]);
		printf("confirmed\t%d\n", info.confirmed);
		printf("SPI      \t%d\n", info.spi);
		printf("timeout  \t%d\n", info.timeout);
	} else {
		printf("Call failed: %s\n", dynamics_fa_get_error_string(r));
	}
}

void cmd_path(int argc, char *argv[])
{
	char *p;

	if (argc < 2) {
		p = dynamics_fa_get_agent_path();
		if (p) printf("Current agent path is \"%s\".\n", p); 
		return;
	} else if (argc > 2) {
		printf("Invalid arguments. Usage 'path <path>'.\n");
		return;
	}

	if (dynamics_fa_init(argv[1]) == API_SUCCESS) {
		printf("Using agent '%s'.\n", argv[1]);
	} else {
		printf("Failed.\n");
	}
}

void cmd_attach(int argc, char *argv[])
{
	if (argc != 2) {
		printf("Invalid arguments. Usage 'attach <path>'.\n");
		return;
	}

	if (dynamics_fa_attach_socket_info(argv[1]) == API_SUCCESS)
		printf("Succeeded.\n");
	else
		printf("Failed.\n");
}

void cmd_detach(int argc, char *argv[])
{
	if (argc != 2) {
		printf("Invalid arguments. Usage 'detach <path>'.\n");
		return;
	}

	if (dynamics_fa_detach_socket_info(argv[1]) == API_SUCCESS)
		printf("Succeeded.\n");
	else
		printf("Failed.\n");
}