regsim.c

mobile ip 在linux下的一种实现

/* $Id: regsim.c,v 1.5 2001/08/05 17:06:12 jm Exp $
 * Program for simulating registrations
 *
 * Dynamic hierarchial IP tunnel
 * Copyright (C) 2000-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.
 */

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <string.h>
#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <getopt.h>
#include <time.h>

#include "message.h"
#include "msgparser.h"
#include "md5_mac.h"
#include "util.h"
#include "debug.h"

/* #define PARSE_MSG */
/* #define CHANGE_COA */

extern int opt_debug;

#define MAX_REG 2050


#define MAXMSG 1024

#define DEFAULT_PORT      434
#define DEFAULT_DST_ADDR  "192.168.1.2"

#define DEFAULT_LIFETIME  0xffff
#define DEFAULT_HOME_ADDR "10.0.0.1"
#define DEFAULT_HA_ADDR   "192.168.1.2"
#define DEFAULT_CO_ADDR   "192.168.1.1"
#define DEFAULT_MN_SPI     10000

#define SHARED_SECRET     "test"
#define SHARED_SECRET_LEN 4


static struct {
	char dst_addr[16];
	int port;
	char home_addr[16];
	char co_addr[16];
	char ha_addr[16];
	int mn_spi;
	int lifetime;
} opt;



static struct in_addr next_home_addr;
static FILE *stats;


void
sim_reg(int s, struct sockaddr_in *serv_addr, struct reg_req *req,
	struct msg_auth *auth_ext, int len)
{
	char msg[MAXMSG];
	struct timeval start, end, tv;
	int n, alen, diff;
	fd_set rfds;

#ifdef PARSE_MSG
	struct msg_extensions ext;
#else
	struct reg_rep *rep;
#endif
	static int next_id = 0;
	unsigned char *c;
	int ret;

	req->id[0] = htonl(time(NULL) + UNIX_NTP_DIFF);
	req->id[1] = htonl(next_id++);
	req->home_addr = next_home_addr;
#ifdef CHANGE_COA
	req->co_addr = next_home_addr;
	c = (unsigned char *) &req->co_addr;
	c++;
	*c |= 128;
#endif
	alen = ((char *) auth_ext) - ((char *) req) + 6;
	md5_mac((unsigned char *) SHARED_SECRET, SHARED_SECRET_LEN,
		(unsigned char *) req, alen, MSG_AUTH_DATA(auth_ext));


	c = (unsigned char *) &next_home_addr;
	c += 3;
	while (c > 0) {
		if (*c == 255) {
			*c = 0;
			c--;
		} else {
			(*c)++;
			break;
		}
	}

	gettimeofday(&start, NULL);
	n = sendto(s, req, len, 0,
		   (struct sockaddr *) serv_addr, sizeof(*serv_addr));
	if (n < 0) {
		perror("sendto");
		exit(1);
	}

	FD_ZERO(&rfds);
	FD_SET(s, &rfds);
	tv.tv_sec = 5;
	tv.tv_usec = 0;
	ret = select(s + 1, &rfds, NULL, NULL, &tv);

	if (ret < 0) {
		perror("select");
		fprintf(stats, "%i\tselect FAILED - %s\n", next_id,
			strerror(errno));
		return;
	}
	if (ret == 0) {
		printf("MN: %s - TIMEOUT!\n", inet_ntoa(req->home_addr));
		fprintf(stats, "%i\ttimeout FAILED\n", next_id);
		return;
	}

	n = recvfrom(s, msg, MAXMSG, 0,
		     (struct sockaddr *) NULL, (unsigned int *) NULL);
	gettimeofday(&end, NULL);

	if (n < 0) {
		perror("recvfrom");
		exit(1);
	}

	diff = (end.tv_sec - start.tv_sec) * 1000000 +
		end.tv_usec - start.tv_usec;

	if ((next_id & 255) == 0) {
		printf("MN: %s - time: %i usec\n", inet_ntoa(next_home_addr),
			diff);
	}
	fprintf(stats, "%i\t%i", next_id, diff);

#ifdef PARSE_MSG
	parse_msg(msg, n, &ext);
	if (ext.rep->code != 0) {
		printf("code=%i\n", ext.rep->code);
		fprintf(stats, "\tFAILED[%i]", ext.rep->code);
	}
#else
	rep = (struct reg_rep *) msg;
	if (rep->code != 0) {
		printf("code=%i\n", rep->code);
		fprintf(stats, "\tFAILED[%i]", rep->code);
	}
#endif
	fprintf(stats, "\n");
}


int main(int argc, char *argv[])
{
	int s;
	struct sockaddr_in serv_addr;
	char msg[MAXMSG];
	char *msgpos = msg;
	struct reg_req *req_ext;
	struct msg_auth *auth_ext;
	char *optstring = "a:c:h:l:o:p:rs:";
	signed char c;
	int len, i;

	opt_debug = 1;
	stats = fopen("regsim.log", "w");
	if (stats == NULL) {
		printf("Cannot open regsim.log for writing.\n");
		exit(1);
	}

	/* default arguments */
	dynamics_strlcpy(opt.dst_addr, DEFAULT_DST_ADDR, sizeof(opt.dst_addr));
	opt.port = DEFAULT_PORT;
	dynamics_strlcpy(opt.ha_addr, DEFAULT_HA_ADDR, sizeof(opt.ha_addr));
	dynamics_strlcpy(opt.co_addr, DEFAULT_CO_ADDR, sizeof(opt.co_addr));
	dynamics_strlcpy(opt.home_addr, DEFAULT_HOME_ADDR,
			 sizeof(opt.home_addr));
	opt.mn_spi = DEFAULT_MN_SPI;
	opt.lifetime = DEFAULT_LIFETIME;

	while ((c = getopt(argc, argv, optstring)) != EOF) {
		switch (c) {
		case 'a':
			dynamics_strlcpy(opt.dst_addr, optarg,
					 sizeof(opt.dst_addr));
			break;
		case 'c':
			dynamics_strlcpy(opt.co_addr, optarg,
					 sizeof(opt.co_addr));
			break;
		case 'h':
			dynamics_strlcpy(opt.ha_addr, optarg,
					 sizeof(opt.ha_addr));
			break;
		case 'l':
			opt.lifetime = atoi(optarg);
			break;
		case 'o':
			dynamics_strlcpy(opt.home_addr, optarg,
					 sizeof(opt.home_addr));
			break;
		case 'p':
			opt.port = atoi(optarg);
			break;
		case 's':
			opt.mn_spi = atoi(optarg);
			break;

		default:
			printf("usage: regsim [-a remote_address]"
			       " [-p remote_port] [-c co_addr] [-h ha_addr]"
			       " [-o home_addr] [-l lifetime] [-s mn_spi]\n");
			exit(1);
		}
	}

	/* Registration Request */
	req_ext = (struct reg_req *) msgpos;
	memset(req_ext, 0, sizeof(req_ext));
	req_ext->type = REG_REQ;
	req_ext->opts = 0;
	req_ext->lifetime = htons(opt.lifetime);
	inet_aton(opt.home_addr, &req_ext->home_addr);
	inet_aton(opt.ha_addr, &req_ext->ha_addr);
	inet_aton(opt.co_addr, &req_ext->co_addr);
	msgpos += sizeof(struct reg_req);


	/* Message authentication */
	auth_ext = (struct msg_auth *) msgpos;
	auth_ext->type = MH_AUTH;
	auth_ext->spi = htonl(opt.mn_spi);
	auth_ext->length = MD5_MAC_LEN + SPI_LEN;
	len = msgpos - ((char *)req_ext) + 6;
	md5_mac((unsigned char *) SHARED_SECRET, SHARED_SECRET_LEN,
		(unsigned char *) req_ext, len, MSG_AUTH_DATA(auth_ext));
	msgpos += GET_AUTH_EXT_LEN(auth_ext);


	s = socket(AF_INET, SOCK_DGRAM, 0);
	if (s < 0) {
		perror("socket");
		exit(1);
	}

	memset((char *) &serv_addr, 0, sizeof(serv_addr));
	serv_addr.sin_family = AF_INET;
	inet_aton(opt.dst_addr, &serv_addr.sin_addr);
	serv_addr.sin_port = htons(opt.port);


	inet_aton(opt.home_addr, &next_home_addr);
	for (i = 0; i < MAX_REG; i++)
		sim_reg(s, &serv_addr, req_ext, auth_ext, msgpos - msg);

	close(s);
	fclose(stats);

	return 0;
}