dyn_ip_test.c

mobile ip 在linux下的一种实现

	ret = dyn_ip_get_local_addr(&addr, &local);
	if (ret != 0) {
		fprintf(stderr, "dyn_ip_get_local_addr failed => %i\n", ret);
		exit(-1);
	}
	printf("%s => %s\n", dst, inet_ntoa(local));
}

static void dyn_ip_show(char *dev)
{
	struct in_addr addr;
	int ret;

	ret = dyn_ip_get_ifaddr(dev, &addr);
	if (ret != 0) {
		fprintf(stderr, "dyn_ip_get_ifaddr failed => %i\n", ret);
		exit(-1);
	}
	printf("%s => %s\n", dev, inet_ntoa(addr));
}

static void dyn_ip_memory(void)
{
	struct in_addr dst;
	char dev[16];
	int i, ret;

	printf("dyn_ip_memory\n");
	for (i = 0; i < 10000; i++) {
		fprintf(stderr, ".");
		ret = dyn_ip_route_get(dst, dev, sizeof(dev));
		if (ret != 0) {
			fprintf(stderr, "dyn_ip_route_get returned %i\n", ret);
			return;
		}
	}
	printf("\ndone\n");
}

static void dyn_ip_test2(void)
{
	printf("dyn_ip_test2\n\n");
	printf("Initial default route - ip:\n");
	system(IP_PATH " route show match default");

	printf("\nSaving default route\n");
	if (dyn_ip_route_save_default(NULL) != 0) {
		printf("dyn_ip_route_save_default() failed\n");
		return;
	}

	printf("\nReplacing the default route\n"
	       "If you are using this test remotely, this may be the last\n"
	       "line you will see... But, you were warned ;)\n");
	system(IP_PATH " route replace default dev lo");
	printf("Broken default route - ip:\n");
	system(IP_PATH " route show match default");

	printf("\nRestoring the saved default route\n");
	if (dyn_ip_route_restore_default(NULL) != 0) {
		printf("dyn_ip_route_restore_default() failed\n");
	}

	printf("Returned default route - ip:\n");
	system(IP_PATH " route show match default");

	printf("\nSetting default route to dev lo with own function\n");
	if (dyn_ip_route_replace_default("lo", NULL, NULL) != 0) {
		printf("dyn_ip_route_replace_default failed\n");
	}
	printf("Default route - ip:\n");
	system(IP_PATH " route show match default");

	printf("\nRestoring the saved default route\n");
	if (dyn_ip_route_restore_default(NULL) !=  0) {
		printf("dyn_ip_route_restore_default() failed\n");
	}
	printf("Final default route - ip:\n");
	system(IP_PATH " route show match default");
}

static void dyn_ip_flush(void)
{
	printf("Old routing cache:\n");
	system(IP_PATH " route show table cache");

	printf("Flushing route cache\n");
	if (dyn_ip_route_cache_flush() != 0) {
		printf("Route cache flushing failed!\n");
	}

	printf("New routing cache:\n");
	system(IP_PATH " route show table cache");
}

static void dyn_ip_default(char *dev)
{
	if (dyn_ip_route_replace_default(dev, NULL, NULL) != 0) {
		printf("Route replace failed\n");
	}
}

static void dyn_ip_host(char *addr)
{
	struct in_addr a;

	inet_aton(addr, &a);
	if (dyn_ip_route_to_host(a) != 0)
		printf("Route to host failed\n");
}

static void dyn_ip_exists(char *_addr, char *_prefix_len)
{
	struct in_addr addr;
	int prefix_len;

	inet_aton(_addr, &addr);
	prefix_len = atoi(_prefix_len);

	printf("%s/%i - %s\n", inet_ntoa(addr), prefix_len,
	       dyn_ip_route_exists(&addr, prefix_len) ? "found" : "not found");
}


static void dyn_ip_monitor(char *dev)
{
	fd_set rfds;
	int retval;
	struct current_route_info cur;
	int fd = dyn_ip_monitor_open();

	memset(&cur, 0, sizeof(cur));
	cur.known = 1;
	inet_aton("1.2.3.4", &cur.via);
	dynamics_strlcpy(cur.ifname, dev, sizeof(cur.ifname));
	cur.ifindex = dyn_ip_get_ifindex(dev);
	if (cur.ifindex < 0) {
		fprintf(stderr, "'%s' not available\n", dev);
		exit(1);
	}
	inet_aton("192.168.200.0", &cur.net);
	cur.prefix_len = 24;
	cur.ifindex_net = cur.ifindex;
	memcpy(cur.ifname_net, cur.ifname, IFNAMSIZ);

	if (fd < 0) {
		fprintf(stderr, "Could not initiate monitoring.\n");
		return;
	}

	for (;;) {
		FD_ZERO(&rfds);
		FD_SET(fd, &rfds);
		retval = select(fd + 1, &rfds, NULL, NULL, NULL);
		if (retval <= 0) {
			printf("select returned %i\n", retval);
			exit(1);
		}

		if (!FD_ISSET(fd, &rfds)) {
			printf("!FD_ISSET?\n");
			exit(1);
		}

		printf("dyn_ip_monitor_get:\n");
		retval = dyn_ip_monitor_get(fd, &cur);
		printf("ret ==> %i\n", retval);
	}
}

static void dyn_ip_addr_if(char *iface, char *addrS)
{
	struct in_addr addr;
	int ret, ifindex;

	ifindex = atoi(iface);
	inet_aton(addrS, &addr);
	printf("ifindex=%i, addr=%s\n", ifindex, inet_ntoa(addr));
	ret = dyn_ip_iface_address(ifindex, &addr);
	printf("dyn_ip_iface_address => %i\n", ret);
}

static void dyn_ip_rule_local(void)
{
	printf("Routing rules before test:\n");
	system(IP_PATH " rule show");

	printf("Adding ip rule for locally generated packets.\n");
	if (dyn_ip_rule_add_table(NULL, NULL, 10, "lo")) {
		printf("Rule adding failed\n");
	}

	printf("Routing rules:\n");
	system(IP_PATH " rule show");

	printf("Removing ip rule for locally generated packets.\n");
	if (dyn_ip_rule_del_table(NULL, NULL, 10, "lo")) {
		printf("Rule removal failed\n");
	}

	printf("Routing rules after test:\n");
	system(IP_PATH " rule show");
}

static void show_usage(void)
{
	fprintf(stderr, "Tunnel and route interface routine tests\n"
		"dyn_ip_test test = basic module tests\n"
		"dyn_ip_test test2 = test the default route saving\n"
		"   (in case of some error, this will break your routing, so "
		"be careful ;)\n"
		"dyn_ip_test dst <dst> = get the interface for "
		"destination address\n"
		"dyn_ip_test local <dst> = get a local address of the "
		"interface of destination address\n"
		"dyn_ip_test dev <interface> = show the primary local address"
		" of the given interface\n"
		"dyn_ip_test memory = repeat operations to check for memory"
		" leaks\n"
		"dyn_ip_test default <dev> = change the default route to given"
		" device\n"
		"dyn_ip_test exists <addr prefix> <prefix len> = check "
		"routing entry existance\n"
		"dyn_ip_test monitor <iface> = monitor rtnetlink\n"
		"dyn_ip_test addr_if <iface> <addr>\n"
		"dyn_ip_test rule_local = local packets using a separate "
		"table\n"
		"dyn_ip_test flush = flush the kernel route cache\n");
	exit(-1);
}

int main(int argc, char *argv[])
{
	opt_debug = 1;

	if (argc < 2)
		show_usage();

	if (strcmp(argv[1], "test") == 0) {
		dyn_ip_tests();
		return 0;
	} else if (strcmp(argv[1], "test2") == 0) {
		dyn_ip_test2();
		return 0;
	} else if (strcmp(argv[1], "dst") == 0) {
		if (argc < 3)
			show_usage();

		dyn_ip_get(argv[2]);
		return 0;
	} else if (strcmp(argv[1], "local") == 0) {
		if (argc < 3)
			show_usage();

		dyn_ip_local(argv[2]);
		return 0;
	} else if (strcmp(argv[1], "dev") == 0) {
		if (argc < 3)
			show_usage();

		dyn_ip_show(argv[2]);
		return 0;
	} else if (strcmp(argv[1], "host") == 0) {
		if (argc < 3)
			show_usage();

		dyn_ip_host(argv[2]);
		return 0;
	} else if (strcmp(argv[1], "memory") == 0) {
		dyn_ip_memory();
		return 0;
	} else if (strcmp(argv[1], "flush") == 0) {
		dyn_ip_flush();
		return 0;
	} else if (strcmp(argv[1], "exists") == 0) {
		if (argc < 4)
			show_usage();

		dyn_ip_exists(argv[2], argv[3]);
		return 0;
	} else if (strcmp(argv[1], "monitor") == 0) {
		if (argc < 3)
			show_usage();
		dyn_ip_monitor(argv[2]);
		return 0;
	} else if (strcmp(argv[1], "addr_if") == 0) {
		if (argc < 4)
			show_usage();
		dyn_ip_addr_if(argv[2], argv[3]);
		return 0;
	} else if (strcmp(argv[1], "rule_local") == 0) {
		dyn_ip_rule_local();
		return 0;
	} else if (strcmp(argv[1], "default") == 0) {
		if (argc < 3)
			show_usage();
		dyn_ip_default(argv[1]);
		return 0;
	}

	show_usage();
	return 0; /* not reached */
}