[people/ms/libloc.git] / src / python / database.c

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

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

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

	This library 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
	Lesser General Public License for more details.
*/

#include <Python.h>

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

#include "locationmodule.h"
#include "as.h"
#include "country.h"
#include "database.h"
#include "network.h"

static PyObject* Database_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
	DatabaseObject* self = (DatabaseObject*)type->tp_alloc(type, 0);

	return (PyObject*)self;
}

static void Database_dealloc(DatabaseObject* self) {
	if (self->db)
		loc_database_unref(self->db);

	if (self->path)
		free(self->path);

	Py_TYPE(self)->tp_free((PyObject* )self);
}

static int Database_init(DatabaseObject* self, PyObject* args, PyObject* kwargs) {
	const char* path = NULL;

	if (!PyArg_ParseTuple(args, "s", &path))
		return -1;

	self->path = strdup(path);

	// Open the file for reading
	FILE* f = fopen(self->path, "r");
	if (!f) {
		PyErr_SetFromErrno(PyExc_IOError);
		return -1;
	}

	// Load the database
	int r = loc_database_new(loc_ctx, &self->db, f);
	fclose(f);

	// Return on any errors
	if (r)
		return -1;

	return 0;
}

static PyObject* Database_repr(DatabaseObject* self) {
	return PyUnicode_FromFormat("<Database %s>", self->path);
}

static PyObject* Database_verify(DatabaseObject* self, PyObject* args) {
	PyObject* public_key = NULL;
	FILE* f = NULL;

	// Parse arguments
	if (!PyArg_ParseTuple(args, "O", &public_key))
		return NULL;

	// Convert into FILE*
	int fd = PyObject_AsFileDescriptor(public_key);
	if (fd < 0)
		return NULL;

	// Re-open file descriptor
	f = fdopen(fd, "r");
	if (!f) {
		PyErr_SetFromErrno(PyExc_IOError);
		return NULL;
	}

	int r = loc_database_verify(self->db, f);

	if (r == 0)
		Py_RETURN_TRUE;

	Py_RETURN_FALSE;
}

static PyObject* Database_get_description(DatabaseObject* self) {
	const char* description = loc_database_get_description(self->db);

	return PyUnicode_FromString(description);
}

static PyObject* Database_get_vendor(DatabaseObject* self) {
	const char* vendor = loc_database_get_vendor(self->db);

	return PyUnicode_FromString(vendor);
}

static PyObject* Database_get_license(DatabaseObject* self) {
	const char* license = loc_database_get_license(self->db);

	return PyUnicode_FromString(license);
}

static PyObject* Database_get_created_at(DatabaseObject* self) {
	time_t created_at = loc_database_created_at(self->db);

	return PyLong_FromLong(created_at);
}

static PyObject* Database_get_as(DatabaseObject* self, PyObject* args) {
	struct loc_as* as = NULL;
	uint32_t number = 0;

	if (!PyArg_ParseTuple(args, "i", &number))
		return NULL;

	// Try to retrieve the AS
	int r = loc_database_get_as(self->db, &as, number);

	// We got an AS
	if (r == 0) {
		PyObject* obj = new_as(&ASType, as);
		loc_as_unref(as);

		return obj;

	// Nothing found
	} else if (r == 1) {
		Py_RETURN_NONE;
	}

	// Unexpected error
	return NULL;
}

static PyObject* Database_get_country(DatabaseObject* self, PyObject* args) {
	const char* country_code = NULL;

	if (!PyArg_ParseTuple(args, "s", &country_code))
		return NULL;

	struct loc_country* country;
	int r = loc_database_get_country(self->db, &country, country_code);
	if (r) {
		Py_RETURN_NONE;
	}

	PyObject* obj = new_country(&CountryType, country);
	loc_country_unref(country);

	return obj;
}

static PyObject* Database_lookup(DatabaseObject* self, PyObject* args) {
	struct loc_network* network = NULL;
	const char* address = NULL;

	if (!PyArg_ParseTuple(args, "s", &address))
		return NULL;

	// Try to retrieve a matching network
	int r = loc_database_lookup_from_string(self->db, address, &network);

	// We got a network
	if (r == 0) {
		PyObject* obj = new_network(&NetworkType, network);
		loc_network_unref(network);

		return obj;

	// Nothing found
	} else if (r == 1) {
		Py_RETURN_NONE;

	// Invalid input
	} else if (r == -EINVAL) {
		PyErr_Format(PyExc_ValueError, "Invalid IP address: %s", address);
		return NULL;
	}

	// Unexpected error
	return NULL;
}

static PyObject* new_database_enumerator(PyTypeObject* type, struct loc_database_enumerator* enumerator) {
	DatabaseEnumeratorObject* self = (DatabaseEnumeratorObject*)type->tp_alloc(type, 0);
	if (self) {
		self->enumerator = loc_database_enumerator_ref(enumerator);
	}

	return (PyObject*)self;
}

static PyObject* Database_search_as(DatabaseObject* self, PyObject* args) {
	const char* string = NULL;

	if (!PyArg_ParseTuple(args, "s", &string))
		return NULL;

	struct loc_database_enumerator* enumerator;

	int r = loc_database_enumerator_new(&enumerator, self->db, LOC_DB_ENUMERATE_ASES);
	if (r) {
		PyErr_SetFromErrno(PyExc_SystemError);
		return NULL;
	}

	// Search string we are searching for
	loc_database_enumerator_set_string(enumerator, string);

	PyObject* obj = new_database_enumerator(&DatabaseEnumeratorType, enumerator);
	loc_database_enumerator_unref(enumerator);

	return obj;
}

static PyObject* Database_search_networks(DatabaseObject* self, PyObject* args, PyObject* kwargs) {
	char* kwlist[] = { "country_code", "asn", "flags", "family", NULL };
	const char* country_code = NULL;
	unsigned int asn = 0;
	int flags = 0;
	int family = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|siii", kwlist, &country_code, &asn, &flags, &family))
		return NULL;

	struct loc_database_enumerator* enumerator;
	int r = loc_database_enumerator_new(&enumerator, self->db, LOC_DB_ENUMERATE_NETWORKS);
	if (r) {
		PyErr_SetFromErrno(PyExc_SystemError);
		return NULL;
	}

	// Set country code we are searching for
	if (country_code) {
		r = loc_database_enumerator_set_country_code(enumerator, country_code);

		if (r) {
			PyErr_SetFromErrno(PyExc_SystemError);
			return NULL;
		}
	}

	// Set the ASN we are searching for
	if (asn) {
		r = loc_database_enumerator_set_asn(enumerator, asn);

		if (r) {
			PyErr_SetFromErrno(PyExc_SystemError);
			return NULL;
		}
	}

	// Set the flags we are searching for
	if (flags) {
		r = loc_database_enumerator_set_flag(enumerator, flags);

		if (r) {
			PyErr_SetFromErrno(PyExc_SystemError);
			return NULL;
		}
	}

	// Set the family we are searching for
	if (family) {
		r = loc_database_enumerator_set_family(enumerator, family);

		if (r) {
			PyErr_SetFromErrno(PyExc_SystemError);
			return NULL;
		}
	}

	PyObject* obj = new_database_enumerator(&DatabaseEnumeratorType, enumerator);
	loc_database_enumerator_unref(enumerator);

	return obj;
}

static struct PyMethodDef Database_methods[] = {
	{
		"get_as",
		(PyCFunction)Database_get_as,
		METH_VARARGS,
		NULL,
	},
	{
		"get_country",
		(PyCFunction)Database_get_country,
		METH_VARARGS,
		NULL,
	},
	{
		"lookup",
		(PyCFunction)Database_lookup,
		METH_VARARGS,
		NULL,
	},
	{
		"search_as",
		(PyCFunction)Database_search_as,
		METH_VARARGS,
		NULL,
	},
	{
		"search_networks",
		(PyCFunction)Database_search_networks,
		METH_VARARGS|METH_KEYWORDS,
		NULL,
	},
	{
		"verify",
		(PyCFunction)Database_verify,
		METH_VARARGS,
		NULL,
	},
	{ NULL },
};

static struct PyGetSetDef Database_getsetters[] = {
	{
		"created_at",
		(getter)Database_get_created_at,
		NULL,
		NULL,
		NULL,
	},
	{
		"description",
		(getter)Database_get_description,
		NULL,
		NULL,
		NULL,
	},
	{
		"license",
		(getter)Database_get_license,
		NULL,
		NULL,
		NULL,
	},
	{
		"vendor",
		(getter)Database_get_vendor,
		NULL,
		NULL,
		NULL,
	},
	{ NULL },
};

PyTypeObject DatabaseType = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name =               "location.Database",
	.tp_basicsize =          sizeof(DatabaseObject),
	.tp_flags =              Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
	.tp_new =                Database_new,
	.tp_dealloc =            (destructor)Database_dealloc,
	.tp_init =               (initproc)Database_init,
	.tp_doc =                "Database object",
	.tp_methods =            Database_methods,
	.tp_getset =             Database_getsetters,
	.tp_repr =               (reprfunc)Database_repr,
};

static PyObject* DatabaseEnumerator_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
	DatabaseEnumeratorObject* self = (DatabaseEnumeratorObject*)type->tp_alloc(type, 0);

	return (PyObject*)self;
}

static void DatabaseEnumerator_dealloc(DatabaseEnumeratorObject* self) {
	loc_database_enumerator_unref(self->enumerator);

	Py_TYPE(self)->tp_free((PyObject* )self);
}

static PyObject* DatabaseEnumerator_next(DatabaseEnumeratorObject* self) {
	struct loc_network* network = NULL;

	// Enumerate all networks
	int r = loc_database_enumerator_next_network(self->enumerator, &network);
	if (r) {
		PyErr_SetFromErrno(PyExc_ValueError);
		return NULL;
	}

	// A network was found
	if (network) {
		PyObject* obj = new_network(&NetworkType, network);
		loc_network_unref(network);

		return obj;
	}

	// Enumerate all ASes
	struct loc_as* as = NULL;

	r = loc_database_enumerator_next_as(self->enumerator, &as);
	if (r) {
		PyErr_SetFromErrno(PyExc_ValueError);
		return NULL;
	}

	if (as) {
		PyObject* obj = new_as(&ASType, as);
		loc_as_unref(as);

		return obj;
	}

	// Nothing found, that means the end
	PyErr_SetNone(PyExc_StopIteration);
	return NULL;
}

PyTypeObject DatabaseEnumeratorType = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name =               "location.DatabaseEnumerator",
	.tp_basicsize =          sizeof(DatabaseEnumeratorObject),
	.tp_flags =              Py_TPFLAGS_DEFAULT,
	.tp_alloc =              PyType_GenericAlloc,
	.tp_new =                DatabaseEnumerator_new,
	.tp_dealloc =            (destructor)DatabaseEnumerator_dealloc,
	.tp_iter =               PyObject_SelfIter,
	.tp_iternext =           (iternextfunc)DatabaseEnumerator_next,
};
Commit	Line	Data
9cdf6c53 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 library is free software; you can redistribute it and/or
	7	modify it under the terms of the GNU Lesser General Public
	8	License as published by the Free Software Foundation; either
	9	version 2.1 of the License, or (at your option) any later version.
	10
	11	This library 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 GNU
	14	Lesser General Public License for more details.
	15	*/
	16
	17	#include <Python.h>
	18
9fc7f001 MT	19	#include <loc/libloc.h>
	20	#include <loc/database.h>
	21
1da9cd39	22	#include "locationmodule.h"
86ca7ef7	23	#include "as.h"
7c922e9c	24	#include "country.h"
9cdf6c53	25	#include "database.h"
31edab76	26	#include "network.h"
9cdf6c53 MT	27
9cdf6c53 MT	28	static PyObject* Database_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
9cdf6c53	29	DatabaseObject* self = (DatabaseObject*)type->tp_alloc(type, 0);
9cdf6c53 MT	30
	31	return (PyObject*)self;
	32	}
	33
	34	static void Database_dealloc(DatabaseObject* self) {
	35	if (self->db)
	36	loc_database_unref(self->db);
	37
6fd96715 MT	38	if (self->path)
	39	free(self->path);
	40
9cdf6c53 MT	41	Py_TYPE(self)->tp_free((PyObject* )self);
	42	}
	43
	44	static int Database_init(DatabaseObject* self, PyObject* args, PyObject* kwargs) {
	45	const char* path = NULL;
	46
	47	if (!PyArg_ParseTuple(args, "s", &path))
	48	return -1;
	49
6fd96715 MT	50	self->path = strdup(path);
6fd96715 MT	51
9cdf6c53	52	// Open the file for reading
6fd96715	53	FILE* f = fopen(self->path, "r");
774eea26 MT	54	if (!f) {
774eea26 MT	55	PyErr_SetFromErrno(PyExc_IOError);
9cdf6c53	56	return -1;
774eea26	57	}
9cdf6c53 MT	58
9cdf6c53 MT	59	// Load the database
38e07ee0	60	int r = loc_database_new(loc_ctx, &self->db, f);
9cdf6c53 MT	61	fclose(f);
	62
	63	// Return on any errors
	64	if (r)
	65	return -1;
	66
	67	return 0;
	68	}
	69
6fd96715 MT	70	static PyObject* Database_repr(DatabaseObject* self) {
	71	return PyUnicode_FromFormat("<Database %s>", self->path);
	72	}
	73
726f9984 MT	74	static PyObject* Database_verify(DatabaseObject* self, PyObject* args) {
	75	PyObject* public_key = NULL;
	76	FILE* f = NULL;
	77
	78	// Parse arguments
	79	if (!PyArg_ParseTuple(args, "O", &public_key))
	80	return NULL;
	81
	82	// Convert into FILE*
	83	int fd = PyObject_AsFileDescriptor(public_key);
	84	if (fd < 0)
	85	return NULL;
	86
	87	// Re-open file descriptor
	88	f = fdopen(fd, "r");
	89	if (!f) {
	90	PyErr_SetFromErrno(PyExc_IOError);
	91	return NULL;
	92	}
	93
	94	int r = loc_database_verify(self->db, f);
b1720435 MT	95
	96	if (r == 0)
	97	Py_RETURN_TRUE;
	98
	99	Py_RETURN_FALSE;
	100	}
	101
d99b0256 MT	102	static PyObject* Database_get_description(DatabaseObject* self) {
	103	const char* description = loc_database_get_description(self->db);
	104
	105	return PyUnicode_FromString(description);
	106	}
	107
	108	static PyObject* Database_get_vendor(DatabaseObject* self) {
	109	const char* vendor = loc_database_get_vendor(self->db);
	110
	111	return PyUnicode_FromString(vendor);
	112	}
	113
4bf49d00 MT	114	static PyObject* Database_get_license(DatabaseObject* self) {
	115	const char* license = loc_database_get_license(self->db);
	116
	117	return PyUnicode_FromString(license);
	118	}
	119
53524b2d MT	120	static PyObject* Database_get_created_at(DatabaseObject* self) {
	121	time_t created_at = loc_database_created_at(self->db);
	122
	123	return PyLong_FromLong(created_at);
	124	}
	125
86ca7ef7 MT	126	static PyObject* Database_get_as(DatabaseObject* self, PyObject* args) {
	127	struct loc_as* as = NULL;
	128	uint32_t number = 0;
	129
	130	if (!PyArg_ParseTuple(args, "i", &number))
	131	return NULL;
	132
	133	// Try to retrieve the AS
	134	int r = loc_database_get_as(self->db, &as, number);
86ca7ef7	135
4a0a0f7e MT	136	// We got an AS
4a0a0f7e MT	137	if (r == 0) {
86ca7ef7 MT	138	PyObject* obj = new_as(&ASType, as);
	139	loc_as_unref(as);
	140
	141	return obj;
86ca7ef7 MT	142
86ca7ef7 MT	143	// Nothing found
4a0a0f7e MT	144	} else if (r == 1) {
	145	Py_RETURN_NONE;
	146	}
	147
	148	// Unexpected error
	149	return NULL;
86ca7ef7 MT	150	}
86ca7ef7 MT	151
7c922e9c MT	152	static PyObject* Database_get_country(DatabaseObject* self, PyObject* args) {
	153	const char* country_code = NULL;
	154
	155	if (!PyArg_ParseTuple(args, "s", &country_code))
	156	return NULL;
	157
	158	struct loc_country* country;
	159	int r = loc_database_get_country(self->db, &country, country_code);
	160	if (r) {
	161	Py_RETURN_NONE;
	162	}
	163
	164	PyObject* obj = new_country(&CountryType, country);
	165	loc_country_unref(country);
	166
	167	return obj;
	168	}
	169
31edab76 MT	170	static PyObject* Database_lookup(DatabaseObject* self, PyObject* args) {
	171	struct loc_network* network = NULL;
	172	const char* address = NULL;
	173
	174	if (!PyArg_ParseTuple(args, "s", &address))
	175	return NULL;
	176
	177	// Try to retrieve a matching network
	178	int r = loc_database_lookup_from_string(self->db, address, &network);
	179
	180	// We got a network
	181	if (r == 0) {
	182	PyObject* obj = new_network(&NetworkType, network);
	183	loc_network_unref(network);
	184
	185	return obj;
	186
	187	// Nothing found
	188	} else if (r == 1) {
	189	Py_RETURN_NONE;
927e82f2 MT	190
	191	// Invalid input
	192	} else if (r == -EINVAL) {
	193	PyErr_Format(PyExc_ValueError, "Invalid IP address: %s", address);
	194	return NULL;
31edab76 MT	195	}
	196
	197	// Unexpected error
	198	return NULL;
	199	}
	200
afb426df MT	201	static PyObject* new_database_enumerator(PyTypeObject* type, struct loc_database_enumerator* enumerator) {
	202	DatabaseEnumeratorObject* self = (DatabaseEnumeratorObject*)type->tp_alloc(type, 0);
	203	if (self) {
	204	self->enumerator = loc_database_enumerator_ref(enumerator);
	205	}
	206
	207	return (PyObject*)self;
	208	}
	209
	210	static PyObject* Database_search_as(DatabaseObject* self, PyObject* args) {
	211	const char* string = NULL;
	212
	213	if (!PyArg_ParseTuple(args, "s", &string))
	214	return NULL;
	215
	216	struct loc_database_enumerator* enumerator;
	217
ccc7ab4e	218	int r = loc_database_enumerator_new(&enumerator, self->db, LOC_DB_ENUMERATE_ASES);
afb426df MT	219	if (r) {
	220	PyErr_SetFromErrno(PyExc_SystemError);
	221	return NULL;
	222	}
	223
	224	// Search string we are searching for
	225	loc_database_enumerator_set_string(enumerator, string);
	226
	227	PyObject* obj = new_database_enumerator(&DatabaseEnumeratorType, enumerator);
	228	loc_database_enumerator_unref(enumerator);
	229
	230	return obj;
	231	}
	232
ccc7ab4e	233	static PyObject* Database_search_networks(DatabaseObject* self, PyObject* args, PyObject* kwargs) {
44e5ef71	234	char* kwlist[] = { "country_code", "asn", "flags", "family", NULL };
ccc7ab4e MT	235	const char* country_code = NULL;
ccc7ab4e MT	236	unsigned int asn = 0;
bbdb2e0a	237	int flags = 0;
44e5ef71	238	int family = 0;
ccc7ab4e	239
44e5ef71	240	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "\|siii", kwlist, &country_code, &asn, &flags, &family))
ccc7ab4e MT	241	return NULL;
	242
	243	struct loc_database_enumerator* enumerator;
	244	int r = loc_database_enumerator_new(&enumerator, self->db, LOC_DB_ENUMERATE_NETWORKS);
	245	if (r) {
	246	PyErr_SetFromErrno(PyExc_SystemError);
	247	return NULL;
	248	}
	249
	250	// Set country code we are searching for
	251	if (country_code) {
	252	r = loc_database_enumerator_set_country_code(enumerator, country_code);
	253
	254	if (r) {
	255	PyErr_SetFromErrno(PyExc_SystemError);
	256	return NULL;
	257	}
	258	}
	259
	260	// Set the ASN we are searching for
	261	if (asn) {
	262	r = loc_database_enumerator_set_asn(enumerator, asn);
	263
	264	if (r) {
	265	PyErr_SetFromErrno(PyExc_SystemError);
	266	return NULL;
	267	}
	268	}
	269
bbdb2e0a MT	270	// Set the flags we are searching for
	271	if (flags) {
	272	r = loc_database_enumerator_set_flag(enumerator, flags);
	273
	274	if (r) {
	275	PyErr_SetFromErrno(PyExc_SystemError);
	276	return NULL;
	277	}
	278	}
	279
44e5ef71 MT	280	// Set the family we are searching for
	281	if (family) {
	282	r = loc_database_enumerator_set_family(enumerator, family);
	283
	284	if (r) {
	285	PyErr_SetFromErrno(PyExc_SystemError);
	286	return NULL;
	287	}
	288	}
	289
ccc7ab4e MT	290	PyObject* obj = new_database_enumerator(&DatabaseEnumeratorType, enumerator);
	291	loc_database_enumerator_unref(enumerator);
	292
	293	return obj;
	294	}
	295
9cdf6c53	296	static struct PyMethodDef Database_methods[] = {
86ca7ef7 MT	297	{
	298	"get_as",
	299	(PyCFunction)Database_get_as,
	300	METH_VARARGS,
	301	NULL,
	302	},
7c922e9c MT	303	{
	304	"get_country",
	305	(PyCFunction)Database_get_country,
	306	METH_VARARGS,
	307	NULL,
	308	},
31edab76 MT	309	{
	310	"lookup",
	311	(PyCFunction)Database_lookup,
	312	METH_VARARGS,
	313	NULL,
	314	},
afb426df MT	315	{
	316	"search_as",
	317	(PyCFunction)Database_search_as,
	318	METH_VARARGS,
	319	NULL,
	320	},
ccc7ab4e MT	321	{
	322	"search_networks",
	323	(PyCFunction)Database_search_networks,
	324	METH_VARARGS\|METH_KEYWORDS,
	325	NULL,
	326	},
b1720435 MT	327	{
	328	"verify",
	329	(PyCFunction)Database_verify,
726f9984	330	METH_VARARGS,
b1720435 MT	331	NULL,
b1720435 MT	332	},
9cdf6c53 MT	333	{ NULL },
	334	};
	335
d99b0256	336	static struct PyGetSetDef Database_getsetters[] = {
53524b2d MT	337	{
	338	"created_at",
	339	(getter)Database_get_created_at,
	340	NULL,
	341	NULL,
	342	NULL,
	343	},
d99b0256 MT	344	{
	345	"description",
	346	(getter)Database_get_description,
	347	NULL,
	348	NULL,
	349	NULL,
	350	},
4bf49d00 MT	351	{
	352	"license",
	353	(getter)Database_get_license,
	354	NULL,
	355	NULL,
	356	NULL,
	357	},
d99b0256 MT	358	{
	359	"vendor",
	360	(getter)Database_get_vendor,
	361	NULL,
	362	NULL,
53524b2d	363	NULL,
d99b0256 MT	364	},
	365	{ NULL },
	366	};
	367
9cdf6c53 MT	368	PyTypeObject DatabaseType = {
9cdf6c53 MT	369	PyVarObject_HEAD_INIT(NULL, 0)
d42e1dcd MT	370	.tp_name = "location.Database",
	371	.tp_basicsize = sizeof(DatabaseObject),
	372	.tp_flags = Py_TPFLAGS_DEFAULT\|Py_TPFLAGS_BASETYPE,
	373	.tp_new = Database_new,
	374	.tp_dealloc = (destructor)Database_dealloc,
	375	.tp_init = (initproc)Database_init,
	376	.tp_doc = "Database object",
	377	.tp_methods = Database_methods,
	378	.tp_getset = Database_getsetters,
	379	.tp_repr = (reprfunc)Database_repr,
9cdf6c53	380	};
afb426df MT	381
	382	static PyObject* DatabaseEnumerator_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
	383	DatabaseEnumeratorObject* self = (DatabaseEnumeratorObject*)type->tp_alloc(type, 0);
	384
	385	return (PyObject*)self;
	386	}
	387
	388	static void DatabaseEnumerator_dealloc(DatabaseEnumeratorObject* self) {
	389	loc_database_enumerator_unref(self->enumerator);
	390
	391	Py_TYPE(self)->tp_free((PyObject* )self);
	392	}
	393
	394	static PyObject* DatabaseEnumerator_next(DatabaseEnumeratorObject* self) {
15f79e2d MT	395	struct loc_network* network = NULL;
15f79e2d MT	396
ccc7ab4e	397	// Enumerate all networks
15f79e2d MT	398	int r = loc_database_enumerator_next_network(self->enumerator, &network);
15f79e2d MT	399	if (r) {
20bb6d0c	400	PyErr_SetFromErrno(PyExc_ValueError);
15f79e2d MT	401	return NULL;
	402	}
	403
	404	// A network was found
ccc7ab4e MT	405	if (network) {
	406	PyObject* obj = new_network(&NetworkType, network);
	407	loc_network_unref(network);
	408
	409	return obj;
	410	}
	411
	412	// Enumerate all ASes
15f79e2d MT	413	struct loc_as* as = NULL;
	414
	415	r = loc_database_enumerator_next_as(self->enumerator, &as);
	416	if (r) {
20bb6d0c	417	PyErr_SetFromErrno(PyExc_ValueError);
15f79e2d MT	418	return NULL;
	419	}
	420
afb426df MT	421	if (as) {
	422	PyObject* obj = new_as(&ASType, as);
	423	loc_as_unref(as);
	424
	425	return obj;
	426	}
	427
	428	// Nothing found, that means the end
	429	PyErr_SetNone(PyExc_StopIteration);
	430	return NULL;
	431	}
	432
	433	PyTypeObject DatabaseEnumeratorType = {
	434	PyVarObject_HEAD_INIT(NULL, 0)
d42e1dcd MT	435	.tp_name = "location.DatabaseEnumerator",
	436	.tp_basicsize = sizeof(DatabaseEnumeratorObject),
	437	.tp_flags = Py_TPFLAGS_DEFAULT,
	438	.tp_alloc = PyType_GenericAlloc,
	439	.tp_new = DatabaseEnumerator_new,
	440	.tp_dealloc = (destructor)DatabaseEnumerator_dealloc,
	441	.tp_iter = PyObject_SelfIter,
	442	.tp_iternext = (iternextfunc)DatabaseEnumerator_next,
afb426df	443	};