autotest.c

mobile ip 在linux下的一种实现

/* $Id: autotest.c,v 1.9 2000/04/06 07:26:53 jm Exp $
 * Automatic system testing by using MN API
 *
 * Dynamic hierarchial IP tunnel
 * Copyright (C) 1998-2000, 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.
 */

#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/time.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>

#include "dyn_mnlib.h"

/* #define CHECK_FA */

#define TIMEOUT 1
#define FA_ADDR "192.168.240.%i"
#define FA_COUNT 14 /* 25 - 39 && not 33 */
#define OWN_ADDR "192.168.240.128"
/* max locupd time to record in milliseconds */
#define MAX_TIME 2000

#ifdef CHECK_FA

#define FA_STATUS_ADDR "192.168.0.1"
#define FA_STATUS_PORT 10434
#define LISTEN_PORT 10434

static int status_s;
static struct sockaddr_in status_addr;

static int upper_FA[FA_COUNT] = { -1, 1, 1, 2, 2, 3, 3,
				  -1, 8, 8, 9, 9, 10, 10 };

/*
      1               8
     / \             / \
    /   \           /   \
   2     3         9    10
  / \   / \       / \   / \
 /  |   |  \     /  |   |  \
4   5   6   7   11  12  13  14
*/

#endif


static struct in_addr own_addr;
static int prev_fa;
static int same_org[MAX_TIME];
static int diff_org[MAX_TIME];
static char fa_ok[FA_COUNT];


static unsigned int usec_passed(struct timeval *tv)
{
	struct timeval now;
	gettimeofday(&now, NULL);
	return (now.tv_sec - tv->tv_sec) * 1000000 + now.tv_usec - tv->tv_usec;
}

void show_status(void)
{
	struct dynamics_mobile_status status;
	int r;

	r = dynamics_mn_get_status(&status, TIMEOUT);
	if (r == API_SUCCESS) {
		printf("Mobile status:\n");
		printf("\tstate     \t%s\n", status.state_str);
		printf("\tlocal addr\t%s\n", inet_ntoa(status.local_addr));
		printf("\tco-addr   \t%s\n", inet_ntoa(status.co_addr));
		printf("\tFA-addr   \t%s\n", inet_ntoa(status.fa_addr));
		printf("\tHA-addr   \t%s\n", inet_ntoa(status.ha_addr));
		printf("\tHome addr \t%s\n", inet_ntoa(status.home_addr));
		if (status.tunnel_up) printf("\ttunnel is \tup\n");
		else printf("\ttunnel is \tdown\n");
		printf("\ttunneling mode\t%d\n", status.tunnel_mode);
	} else 
		printf("Call failed: %s\n", dynamics_mn_get_error_string(r));
}

#ifdef CHECK_FA

int same_fa(struct in_addr *addr, int fa)
{
	return *(((char *)&addr->s_addr) + 3) == fa;
}

void check_fa_status(int fa)
{
	struct in_addr fa_co_addrs[FA_COUNT];
	int r, i, ok;
	unsigned int len;
	struct sockaddr_in addr;

	if (sendto(status_s, "CO", 2, 0, (struct sockaddr *) &status_addr,
		   sizeof(status_addr)) < 0) {
		perror("sendto");
		return;
	}

	len = sizeof(addr);
	r = recvfrom(status_s, fa_co_addrs, sizeof(fa_co_addrs), 0,
		     (struct sockaddr *) &addr, &len);
	if (r < 0) {
		perror("recvfrom");
		return;
	}
	if (r != sizeof(fa_co_addrs)) {
		printf("wrong size %i != %i\n", r, sizeof(fa_co_addrs));
		return;
	}

	ok = 1;
	if (fa_co_addrs[fa - 1].s_addr != own_addr.s_addr) {
		printf("lowestFA co_addr != own addr\n");
		ok = 0;
	} else {
		fa_co_addrs[fa - 1].s_addr = -1;
		i = fa;
		r = upper_FA[fa - 1] + 24;
		if (r == 33) r++;
		while (r != -1) {
			if (!same_fa(&fa_co_addrs[r - 1], i)) {
				printf("FA%i co_addr != FA%i\n", r, i);
				ok = 0;
				break;
			}
			fa_co_addrs[r - 1].s_addr = -1;
			i = r;
			r = upper_FA[r - 1] + 24;
			if (r == 33) r++;
			
		}

		for (i = 0; i < FA_COUNT; i++) {
			if (fa_co_addrs[i].s_addr != -1) {
				printf("extra tunnel in FA%i\n", i + 1);
				ok = 0;
			}
		}
	}

	if (ok == 0) {
		printf("error in one of FAs: ");
		for (i = 0; i < FA_COUNT; i++) {
			printf("[%s]", inet_ntoa(fa_co_addrs[i]));
		}
		printf("\n");
	}
}
#endif

void locupd(int fa)
{
	int ret, count, usec, msec;
	char s[30];
	struct in_addr addr;
	struct dynamics_mobile_status status;
	struct timeval start, end;

	snprintf(s, sizeof(s), FA_ADDR, fa);
	inet_aton(s, &addr);

	printf("locupd => %s: ", s);

	gettimeofday(&start, NULL);

	ret = dynamics_mn_force_fa(&addr, TIMEOUT);
	if (ret != API_SUCCESS) {
		fprintf(stderr, "dynamics_mn_force_fa: %i - %s\n", ret,
			dynamics_mn_get_error_string(ret));
	}

	ret = dynamics_mn_update_location(&own_addr, TIMEOUT);
	if (ret != API_SUCCESS) {
		fprintf(stderr, "dynamics_mn_update_location: %i - %s\n", ret,
			dynamics_mn_get_error_string(ret));
	}

	count = 0;
	for (;;) {
		count++;
		if (count > 200) {
			printf("locupd failed - count > 200\n");
			exit(1);
		}

		ret = dynamics_mn_get_status(&status, TIMEOUT);
		if (ret == API_SUCCESS && status.tunnel_up) {
			gettimeofday(&end, NULL);
			usec = (end.tv_sec - start.tv_sec) * 1000000 +
				end.tv_usec - start.tv_usec;
			msec = usec / 1000;
			printf("FA addr: %s (wait about %i ms)\n",
			       inet_ntoa(status.fa_addr),
			       msec);
			if (addr.s_addr != status.fa_addr.s_addr)
				printf("ERROR! FA addr mismatch\n");

			if (msec < 0 || msec >= MAX_TIME) {
				printf("Time skipped\n");
			} else if ((fa > 7 && prev_fa > 7) ||
				   (fa <= 7 && prev_fa <= 7)) {
				/* same organization */
					same_org[msec]++;
			} else {
				/* organization changed */
				diff_org[msec]++;
			}

#ifdef CHECK_FA
			check_fa_status(fa);
#endif
			break;
		}

		if (ret != API_SUCCESS) {
			printf("dynamics_mn_status: %s\n",
			       dynamics_mn_get_error_string(ret));
			exit(1);
		}

		usleep(2000);
	}

	prev_fa = fa;
}

void random_locupds(int locupds, unsigned int interval)
{
	int i, r, r_o = -1;
	struct timeval t1;
	unsigned int s;
	unsigned long int sleep = 0;

	printf("\nRandom locupds\n\n");

	for (i = 0; i < locupds; i++) {
		do {
			r = 1 + (rand() % FA_COUNT);
			if (r == r_o)
				r--;
			if (r == 0)
				r = 2;
			if (r == 9)
				r += 2;
			if (r == r_o)
				r++;
		} while (!fa_ok[r-1]);
		printf("%i ", i);
/*		printf("new=%d, old=%d\n",r,r_o); */
		r_o = r;
		gettimeofday(&t1,NULL);
		locupd(r+24);
		s = usec_passed(&t1);
		if (interval > s) {
			sleep = (unsigned long int)interval - 
				(unsigned long int)s;
/*			printf(" (sleep %i usecs)\n",sleep); */
			usleep(sleep); 
		}
	}
}


void write_statistics(void)
{
	FILE *f;
	int i;

	printf("\nwriting autotest_same_org.txt\n");
	f = fopen("autotest_same_org.txt", "w");
	if (f == NULL) {
		printf("Cannot write - %s\n", strerror(errno));
		exit(1);
	}
	for (i = 0; i < MAX_TIME; i++) {
		if (same_org[i] > 0)
			fprintf(f, "%i %i\n", i, same_org[i]);
	}
	fclose(f);

	printf("\nwriting autotest_diff_org.txt\n");
	f = fopen("autotest_diff_org.txt", "w");
	if (f == NULL) {
		printf("Cannot write - %s\n", strerror(errno));
		exit(1);
	}
	for (i = 0; i < MAX_TIME; i++) {
		if (diff_org[i] > 0)
			fprintf(f, "%i %i\n", i, diff_org[i]);
	}
	fclose(f);
}

int main(int argc, char *argv[])
{
 	int ret, i, locupds;
	unsigned int interval;


	printf("Dynamics - Automatic system testing by using MN API\n\n");
	if (argc < 4) {
		fprintf(stderr,
			"autotest <locupd interval in usec> "
			"<API admin file name> <locupd count> "
			"[list of FAs to be used]\n"
			"e.g. autotest ival /var/run/dynamics_mn_admin 1024 "
			"     autotest ival /var/run/dynamics_mn_admin 1024 "
			"1,2");
		return -1;
	}


#ifdef CHECK_FA
	status_s = socket(AF_INET, SOCK_DGRAM, 0);
	if (status_s < 0) {
		perror("socket");
		exit(1);
	}

	memset((char *) &status_addr, 0, sizeof(status_addr));
	status_addr.sin_family = AF_INET;
	status_addr.sin_addr.s_addr = INADDR_ANY;
	status_addr.sin_port = htons(LISTEN_PORT);
	if (bind(status_s, (struct sockaddr *) &status_addr,
		 sizeof(status_addr)) < 0) {
		perror("bind");
		exit(1);
	}

	inet_aton(FA_STATUS_ADDR, &status_addr.sin_addr);
	status_addr.sin_port = htons(FA_STATUS_PORT);
#endif

	for (i = 0; i < MAX_TIME; i++) {
		same_org[i] = 0;
		diff_org[i] = 0;
	}

	if (argc > 4) {
		char *tmp = argv[4];
		for (i = 0; i < FA_COUNT; i++)
			fa_ok[i] = 0;
		while (*tmp != '\0') {
			ret = atoi(tmp);
			if (ret <= 0 || ret > FA_COUNT) break;
			fa_ok[ret - 1] = 1;
			while (*tmp != '\0' && isdigit(*tmp)) tmp++;
			while (*tmp != '\0' && !isdigit(*tmp)) tmp++;
		}
		ret = 0;
		printf("using FAs:");
		for (i = 0; i < FA_COUNT; i++) {
			if (fa_ok[i]) {
				ret++;
				printf(" %i", i);
			}
		}
		printf("\n");
		if (ret == 0) {
			printf("No FAs selected - aborting\n");
			return -1;
		}
	} else {
		for (i = 0; i < FA_COUNT; i++)
			fa_ok[i] = 1;
	}

	inet_aton(OWN_ADDR, &own_addr);

	interval = atoi(argv[1]);
	if (interval <= 0) {
		printf("Invalid interval\n");
		return -1;
	} else
		printf("Location update interval is %i\n", interval);

	locupds = atoi(argv[3]);
	if (locupds <= 0) {
		printf("Invalid locupd count\n");
		return -1;
	} else
		printf("Doing %i random locupds\n", locupds);

	printf("Using admin API: %s\n", argv[2]);
	ret = dynamics_mn_init(argv[2]);
	if (ret != API_SUCCESS) {
		fprintf(stderr, "dynamics_mn_init returned %i: %s\n",
			ret, dynamics_mn_get_error_string(ret));
		return -1;
	}

	printf("Connecting..\n");
	prev_fa = 2;
	ret = dynamics_mn_connect(API_TUNNEL_FULL, TIMEOUT);
	if (ret != API_SUCCESS) {
		fprintf(stderr, "dynamics_mn_connect: %i - %s\n", ret,
			dynamics_mn_get_error_string(ret));
		printf("Connection failed!\n");
		return -1;
	}

	show_status();

	random_locupds(locupds,interval);

	printf("Disconnecting..\n");

	ret = dynamics_mn_disconnect(TIMEOUT);
	if (ret != API_SUCCESS) {
		fprintf(stderr, "dynamics_mn_disconnect: %i - %s\n", ret,
			dynamics_mn_get_error_string(ret));
	}

	show_status();

	write_statistics();

	return 0;
}