[location/libloc.git] / src / test-network.c

/*
	libloc - A library to determine the location of someone on the Internet

	Copyright (C) 2017 IPFire Development Team <info@ipfire.org>

	This program is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2 of the License, or
	(at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.
*/

#include <errno.h>
#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>

#include <loc/libloc.h>
#include <loc/database.h>
#include <loc/network.h>
#include <loc/writer.h>

int main(int argc, char** argv) {
	int err;

	struct loc_ctx* ctx;
	err = loc_new(&ctx);
	if (err < 0)
		exit(EXIT_FAILURE);

	// Enable debug logging
	loc_set_log_priority(ctx, LOG_DEBUG);

#if 0
	struct loc_network_tree* tree;
	err = loc_network_tree_new(ctx, &tree);
	if (err) {
		fprintf(stderr, "Could not create the network tree\n");
		exit(EXIT_FAILURE);
	}
#endif

	// Create a network
	struct loc_network* network1;
	err = loc_network_new_from_string(ctx, &network1, "2001:db8::1/32");
	if (err) {
		fprintf(stderr, "Could not create the network\n");
		exit(EXIT_FAILURE);
	}

	err = loc_network_set_country_code(network1, "XX");
	if (err) {
		fprintf(stderr, "Could not set country code\n");
		exit(EXIT_FAILURE);
	}

#if 0
	// Adding network to the tree
	err = loc_network_tree_add_network(tree, network1);
	if (err) {
		fprintf(stderr, "Could not add network to the tree\n");
		exit(EXIT_FAILURE);
	}
#endif

	// Check if the first and last addresses are correct
	char* string = loc_network_format_first_address(network1);
	if (!string) {
		fprintf(stderr, "Did get NULL instead of a string for the first address\n");
		exit(EXIT_FAILURE);
	}

	if (strcmp(string, "2001:db8::") != 0) {
		fprintf(stderr, "Got an incorrect first address: %s\n", string);
		exit(EXIT_FAILURE);
	}

	string = loc_network_format_last_address(network1);
	if (!string) {
		fprintf(stderr, "Did get NULL instead of a string for the last address\n");
		exit(EXIT_FAILURE);
	}

	if (strcmp(string, "2001:db8:ffff:ffff:ffff:ffff:ffff:ffff") != 0) {
		fprintf(stderr, "Got an incorrect last address: %s\n", string);
		exit(EXIT_FAILURE);
	}

	struct loc_network* network2;
	err = loc_network_new_from_string(ctx, &network2, "2001:db8:ffff::/48");
	if (err) {
		fprintf(stderr, "Could not create the network\n");
		exit(EXIT_FAILURE);
	}

	err = loc_network_set_country_code(network2, "XY");
	if (err) {
		fprintf(stderr, "Could not set country code\n");
		exit(EXIT_FAILURE);
	}

#if 0
	// Adding network to the tree
	err = loc_network_tree_add_network(tree, network2);
	if (err) {
		fprintf(stderr, "Could not add network to the tree\n");
		exit(EXIT_FAILURE);
	}

	// Dump the tree
	err = loc_network_tree_dump(tree);
	if (err) {
		fprintf(stderr, "Error dumping tree: %d\n", err);
		exit(EXIT_FAILURE);
	}

	size_t nodes = loc_network_tree_count_nodes(tree);
	printf("The tree has %zu nodes\n", nodes);
#endif

	// Check equals function
	err = loc_network_eq(network1, network1);
	if (!err) {
		fprintf(stderr, "Network is not equal with itself\n");
		exit(EXIT_FAILURE);
	}

	err = loc_network_eq(network1, network2);
	if (err) {
		fprintf(stderr, "Networks equal unexpectedly\n");
		exit(EXIT_FAILURE);
	}

	// Check subnet function
	err = loc_network_is_subnet(network1, network2);
	if (!err) {
		fprintf(stderr, "Subnet check 1 failed: %d\n", err);
		exit(EXIT_FAILURE);
	}

	err = loc_network_is_subnet(network2, network1);
	if (err) {
		fprintf(stderr, "Subnet check 2 failed: %d\n", err);
		exit(EXIT_FAILURE);
	}

	// Make subnets
	struct loc_network* subnet1 = NULL;
	struct loc_network* subnet2 = NULL;

	err  = loc_network_subnets(network1, &subnet1, &subnet2);
	if (err || !subnet1 || !subnet2) {
		fprintf(stderr, "Could not find subnets of network: %d\n", err);
		exit(EXIT_FAILURE);
	}

	char* s = loc_network_str(subnet1);
	printf("Received subnet1 = %s\n", s);
	free(s);

	s = loc_network_str(subnet2);
	printf("Received subnet2 = %s\n", s);
	free(s);

	if (!loc_network_is_subnet(network1, subnet1)) {
		fprintf(stderr, "Subnet1 is not a subnet\n");
		exit(EXIT_FAILURE);
	}

	if (!loc_network_is_subnet(network1, subnet2)) {
		fprintf(stderr, "Subnet2 is not a subnet\n");
		exit(EXIT_FAILURE);
	}

	loc_network_unref(subnet1);
	loc_network_unref(subnet2);

	struct loc_network_list* excluded = loc_network_exclude(network1, network2);
	if (!excluded) {
		fprintf(stderr, "Could not create excluded list\n");
		exit(EXIT_FAILURE);
	}

	loc_network_list_dump(excluded);

	// Reverse it
	loc_network_list_reverse(excluded);
	loc_network_list_dump(excluded);

	// Sort them and dump them again
	loc_network_list_sort(excluded);
	loc_network_list_dump(excluded);

	loc_network_list_unref(excluded);

	// Create a database
	struct loc_writer* writer;
	err = loc_writer_new(ctx, &writer, NULL, NULL);
	if (err < 0)
		exit(EXIT_FAILURE);

	struct loc_network* network3;
	err = loc_writer_add_network(writer, &network3, "2001:db8::/64");
	if (err) {
		fprintf(stderr, "Could not add network\n");
		exit(EXIT_FAILURE);
	}

	// Set country code
	loc_network_set_country_code(network3, "XX");

	struct loc_network* network4;
	err = loc_writer_add_network(writer, &network4, "2001:db8:ffff::/64");
	if (err) {
		fprintf(stderr, "Could not add network\n");
		exit(EXIT_FAILURE);
	}

	// Set country code
	loc_network_set_country_code(network4, "XY");

	// Set ASN
	loc_network_set_asn(network4, 1024);

	// Try adding an invalid network
	struct loc_network* network;
	err = loc_writer_add_network(writer, &network, "xxxx:xxxx::/32");
	if (err != -EINVAL) {
		fprintf(stderr, "It was possible to add an invalid network (err = %d)\n", err);
		exit(EXIT_FAILURE);
	}

	// Try adding a single address
	err = loc_writer_add_network(writer, &network, "2001:db8::");
	if (err) {
		fprintf(stderr, "It was impossible to add an single IP address (err = %d)\n", err);
		exit(EXIT_FAILURE);
	}

	// Try adding localhost
	err = loc_writer_add_network(writer, &network, "::1/128");
	if (err != -EINVAL) {
		fprintf(stderr, "It was possible to add localhost (::1/128): %d\n", err);
		exit(EXIT_FAILURE);
	}

	FILE* f = tmpfile();
	if (!f) {
		fprintf(stderr, "Could not open file for writing: %s\n", strerror(errno));
		exit(EXIT_FAILURE);
	}

	err = loc_writer_write(writer, f, LOC_DATABASE_VERSION_UNSET);
	if (err) {
		fprintf(stderr, "Could not write database: %s\n", strerror(-err));
		exit(EXIT_FAILURE);
	}
	loc_writer_unref(writer);

	loc_network_unref(network1);
	loc_network_unref(network2);
	loc_network_unref(network3);
	loc_network_unref(network4);

#if 0
	loc_network_tree_unref(tree);
#endif

	// And open it again from disk
	struct loc_database* db;
	err = loc_database_new(ctx, &db, f);
	if (err) {
		fprintf(stderr, "Could not open database: %s\n", strerror(-err));
		exit(EXIT_FAILURE);
	}

	// Lookup an address in the subnet
	err = loc_database_lookup_from_string(db, "2001:db8::", &network1);
	if (err) {
		fprintf(stderr, "Could not look up 2001:db8::\n");
		exit(EXIT_FAILURE);
	}
	loc_network_unref(network1);

	// Lookup an address outside the subnet
	err = loc_database_lookup_from_string(db, "2001:db8:fffe:1::", &network1);
	if (err == 0) {
		fprintf(stderr, "Could look up 2001:db8:fffe:1::, but I shouldn't\n");
		exit(EXIT_FAILURE);
	}
	loc_network_unref(network1);

	loc_unref(ctx);
	fclose(f);

	return EXIT_SUCCESS;
}
Commit	Line	Data
3b5f4af2 MT	1	/*
	2	libloc - A library to determine the location of someone on the Internet
	3
	4	Copyright (C) 2017 IPFire Development Team <info@ipfire.org>
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2 of the License, or
	9	(at your option) any later version.
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15	*/
	16
f3e02bc5	17	#include <errno.h>
3b5f4af2 MT	18	#include <stdio.h>
	19	#include <stddef.h>
	20	#include <stdlib.h>
	21	#include <string.h>
37317e4f	22	#include <syslog.h>
3b5f4af2 MT	23
3b5f4af2 MT	24	#include <loc/libloc.h>
2a30e4de	25	#include <loc/database.h>
3b5f4af2	26	#include <loc/network.h>
f3e02bc5	27	#include <loc/writer.h>
3b5f4af2 MT	28
	29	int main(int argc, char** argv) {
	30	int err;
	31
	32	struct loc_ctx* ctx;
	33	err = loc_new(&ctx);
	34	if (err < 0)
	35	exit(EXIT_FAILURE);
	36
37317e4f MT	37	// Enable debug logging
	38	loc_set_log_priority(ctx, LOG_DEBUG);
	39
7933f5bf	40	#if 0
3b5f4af2 MT	41	struct loc_network_tree* tree;
	42	err = loc_network_tree_new(ctx, &tree);
	43	if (err) {
	44	fprintf(stderr, "Could not create the network tree\n");
	45	exit(EXIT_FAILURE);
	46	}
7933f5bf	47	#endif
3b5f4af2 MT	48
	49	// Create a network
	50	struct loc_network* network1;
2b9338ea	51	err = loc_network_new_from_string(ctx, &network1, "2001:db8::1/32");
3b5f4af2 MT	52	if (err) {
	53	fprintf(stderr, "Could not create the network\n");
	54	exit(EXIT_FAILURE);
	55	}
	56
	57	err = loc_network_set_country_code(network1, "XX");
	58	if (err) {
	59	fprintf(stderr, "Could not set country code\n");
	60	exit(EXIT_FAILURE);
	61	}
	62
7933f5bf	63	#if 0
3b5f4af2 MT	64	// Adding network to the tree
	65	err = loc_network_tree_add_network(tree, network1);
	66	if (err) {
	67	fprintf(stderr, "Could not add network to the tree\n");
	68	exit(EXIT_FAILURE);
	69	}
7933f5bf	70	#endif
3b5f4af2	71
2b9338ea MT	72	// Check if the first and last addresses are correct
	73	char* string = loc_network_format_first_address(network1);
	74	if (!string) {
	75	fprintf(stderr, "Did get NULL instead of a string for the first address\n");
	76	exit(EXIT_FAILURE);
	77	}
	78
	79	if (strcmp(string, "2001:db8::") != 0) {
	80	fprintf(stderr, "Got an incorrect first address: %s\n", string);
	81	exit(EXIT_FAILURE);
	82	}
	83
	84	string = loc_network_format_last_address(network1);
	85	if (!string) {
	86	fprintf(stderr, "Did get NULL instead of a string for the last address\n");
	87	exit(EXIT_FAILURE);
	88	}
	89
	90	if (strcmp(string, "2001:db8:ffff:ffff:ffff:ffff:ffff:ffff") != 0) {
	91	fprintf(stderr, "Got an incorrect last address: %s\n", string);
	92	exit(EXIT_FAILURE);
	93	}
	94
c051bfad MT	95	struct loc_network* network2;
	96	err = loc_network_new_from_string(ctx, &network2, "2001:db8:ffff::/48");
	97	if (err) {
	98	fprintf(stderr, "Could not create the network\n");
	99	exit(EXIT_FAILURE);
	100	}
	101
	102	err = loc_network_set_country_code(network2, "XY");
	103	if (err) {
	104	fprintf(stderr, "Could not set country code\n");
	105	exit(EXIT_FAILURE);
	106	}
	107
7933f5bf	108	#if 0
c051bfad MT	109	// Adding network to the tree
	110	err = loc_network_tree_add_network(tree, network2);
	111	if (err) {
	112	fprintf(stderr, "Could not add network to the tree\n");
	113	exit(EXIT_FAILURE);
	114	}
	115
3b5f4af2 MT	116	// Dump the tree
	117	err = loc_network_tree_dump(tree);
	118	if (err) {
	119	fprintf(stderr, "Error dumping tree: %d\n", err);
	120	exit(EXIT_FAILURE);
	121	}
	122
940f9c2b MT	123	size_t nodes = loc_network_tree_count_nodes(tree);
940f9c2b MT	124	printf("The tree has %zu nodes\n", nodes);
7933f5bf	125	#endif
940f9c2b	126
850e7516 MT	127	// Check equals function
	128	err = loc_network_eq(network1, network1);
	129	if (!err) {
	130	fprintf(stderr, "Network is not equal with itself\n");
	131	exit(EXIT_FAILURE);
	132	}
	133
	134	err = loc_network_eq(network1, network2);
	135	if (err) {
	136	fprintf(stderr, "Networks equal unexpectedly\n");
	137	exit(EXIT_FAILURE);
	138	}
	139
43554dc4	140	// Check subnet function
a5967330 MT	141	err = loc_network_is_subnet(network1, network2);
a5967330 MT	142	if (!err) {
43554dc4 MT	143	fprintf(stderr, "Subnet check 1 failed: %d\n", err);
	144	exit(EXIT_FAILURE);
	145	}
	146
a5967330 MT	147	err = loc_network_is_subnet(network2, network1);
a5967330 MT	148	if (err) {
43554dc4 MT	149	fprintf(stderr, "Subnet check 2 failed: %d\n", err);
	150	exit(EXIT_FAILURE);
	151	}
	152
a5967330 MT	153	// Make subnets
	154	struct loc_network* subnet1 = NULL;
	155	struct loc_network* subnet2 = NULL;
	156
	157	err = loc_network_subnets(network1, &subnet1, &subnet2);
	158	if (err \|\| !subnet1 \|\| !subnet2) {
	159	fprintf(stderr, "Could not find subnets of network: %d\n", err);
850e7516 MT	160	exit(EXIT_FAILURE);
	161	}
	162
a5967330 MT	163	char* s = loc_network_str(subnet1);
	164	printf("Received subnet1 = %s\n", s);
	165	free(s);
850e7516	166
a5967330 MT	167	s = loc_network_str(subnet2);
	168	printf("Received subnet2 = %s\n", s);
	169	free(s);
850e7516	170
a5967330 MT	171	if (!loc_network_is_subnet(network1, subnet1)) {
	172	fprintf(stderr, "Subnet1 is not a subnet\n");
	173	exit(EXIT_FAILURE);
	174	}
850e7516	175
a5967330 MT	176	if (!loc_network_is_subnet(network1, subnet2)) {
	177	fprintf(stderr, "Subnet2 is not a subnet\n");
	178	exit(EXIT_FAILURE);
850e7516 MT	179	}
850e7516 MT	180
a5967330 MT	181	loc_network_unref(subnet1);
a5967330 MT	182	loc_network_unref(subnet2);
850e7516 MT	183
	184	struct loc_network_list* excluded = loc_network_exclude(network1, network2);
	185	if (!excluded) {
	186	fprintf(stderr, "Could not create excluded list\n");
	187	exit(EXIT_FAILURE);
	188	}
	189
	190	loc_network_list_dump(excluded);
	191
	192	// Reverse it
	193	loc_network_list_reverse(excluded);
	194	loc_network_list_dump(excluded);
	195
	196	// Sort them and dump them again
	197	loc_network_list_sort(excluded);
	198	loc_network_list_dump(excluded);
	199
	200	loc_network_list_unref(excluded);
	201
f3e02bc5 MT	202	// Create a database
f3e02bc5 MT	203	struct loc_writer* writer;
5ce881d4	204	err = loc_writer_new(ctx, &writer, NULL, NULL);
f3e02bc5 MT	205	if (err < 0)
	206	exit(EXIT_FAILURE);
	207
c051bfad	208	struct loc_network* network3;
83a5d737	209	err = loc_writer_add_network(writer, &network3, "2001:db8::/64");
f3e02bc5 MT	210	if (err) {
	211	fprintf(stderr, "Could not add network\n");
	212	exit(EXIT_FAILURE);
	213	}
	214
	215	// Set country code
c051bfad	216	loc_network_set_country_code(network3, "XX");
f3e02bc5	217
83a5d737 MT	218	struct loc_network* network4;
	219	err = loc_writer_add_network(writer, &network4, "2001:db8:ffff::/64");
	220	if (err) {
	221	fprintf(stderr, "Could not add network\n");
	222	exit(EXIT_FAILURE);
	223	}
	224
	225	// Set country code
	226	loc_network_set_country_code(network4, "XY");
	227
9a339aa0 MT	228	// Set ASN
	229	loc_network_set_asn(network4, 1024);
	230
0f1aedbc MT	231	// Try adding an invalid network
	232	struct loc_network* network;
	233	err = loc_writer_add_network(writer, &network, "xxxx:xxxx::/32");
	234	if (err != -EINVAL) {
	235	fprintf(stderr, "It was possible to add an invalid network (err = %d)\n", err);
	236	exit(EXIT_FAILURE);
	237	}
	238
13ad6e69 MT	239	// Try adding a single address
13ad6e69 MT	240	err = loc_writer_add_network(writer, &network, "2001:db8::");
26ab419b MT	241	if (err) {
26ab419b MT	242	fprintf(stderr, "It was impossible to add an single IP address (err = %d)\n", err);
13ad6e69 MT	243	exit(EXIT_FAILURE);
	244	}
	245
6a467e93 MT	246	// Try adding localhost
	247	err = loc_writer_add_network(writer, &network, "::1/128");
	248	if (err != -EINVAL) {
	249	fprintf(stderr, "It was possible to add localhost (::1/128): %d\n", err);
	250	exit(EXIT_FAILURE);
	251	}
	252
6254dca6	253	FILE* f = tmpfile();
f3e02bc5 MT	254	if (!f) {
	255	fprintf(stderr, "Could not open file for writing: %s\n", strerror(errno));
	256	exit(EXIT_FAILURE);
	257	}
	258
22c7b98b	259	err = loc_writer_write(writer, f, LOC_DATABASE_VERSION_UNSET);
f3e02bc5 MT	260	if (err) {
	261	fprintf(stderr, "Could not write database: %s\n", strerror(-err));
	262	exit(EXIT_FAILURE);
	263	}
f3e02bc5 MT	264	loc_writer_unref(writer);
f3e02bc5 MT	265
3b5f4af2	266	loc_network_unref(network1);
c051bfad MT	267	loc_network_unref(network2);
c051bfad MT	268	loc_network_unref(network3);
83a5d737	269	loc_network_unref(network4);
7933f5bf MT	270
7933f5bf MT	271	#if 0
3b5f4af2	272	loc_network_tree_unref(tree);
7933f5bf	273	#endif
2a30e4de MT	274
2a30e4de MT	275	// And open it again from disk
2a30e4de MT	276	struct loc_database* db;
	277	err = loc_database_new(ctx, &db, f);
	278	if (err) {
	279	fprintf(stderr, "Could not open database: %s\n", strerror(-err));
	280	exit(EXIT_FAILURE);
	281	}
	282
e477e813	283	// Lookup an address in the subnet
2a30e4de MT	284	err = loc_database_lookup_from_string(db, "2001:db8::", &network1);
2a30e4de MT	285	if (err) {
e477e813	286	fprintf(stderr, "Could not look up 2001:db8::\n");
2a30e4de MT	287	exit(EXIT_FAILURE);
	288	}
	289	loc_network_unref(network1);
	290
e477e813	291	// Lookup an address outside the subnet
2a30e4de	292	err = loc_database_lookup_from_string(db, "2001:db8:fffe:1::", &network1);
e477e813 MT	293	if (err == 0) {
e477e813 MT	294	fprintf(stderr, "Could look up 2001:db8:fffe:1::, but I shouldn't\n");
2a30e4de MT	295	exit(EXIT_FAILURE);
	296	}
	297	loc_network_unref(network1);
	298
3b5f4af2	299	loc_unref(ctx);
6254dca6	300	fclose(f);
3b5f4af2 MT	301
	302	return EXIT_SUCCESS;
	303	}