[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", NULL };
	const char* country_code = NULL;
	unsigned int asn = 0;
	int flags = 0;

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|sii", kwlist, &country_code, &asn, &flags))
		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;
		}
	}

	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) {
bbdb2e0a	234	char* kwlist[] = { "country_code", "asn", "flags", NULL };
ccc7ab4e MT	235	const char* country_code = NULL;
ccc7ab4e MT	236	unsigned int asn = 0;
bbdb2e0a	237	int flags = 0;
ccc7ab4e	238
bbdb2e0a	239	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "\|sii", kwlist, &country_code, &asn, &flags))
ccc7ab4e MT	240	return NULL;
	241
	242	struct loc_database_enumerator* enumerator;
	243	int r = loc_database_enumerator_new(&enumerator, self->db, LOC_DB_ENUMERATE_NETWORKS);
	244	if (r) {
	245	PyErr_SetFromErrno(PyExc_SystemError);
	246	return NULL;
	247	}
	248
	249	// Set country code we are searching for
	250	if (country_code) {
	251	r = loc_database_enumerator_set_country_code(enumerator, country_code);
	252
	253	if (r) {
	254	PyErr_SetFromErrno(PyExc_SystemError);
	255	return NULL;
	256	}
	257	}
	258
	259	// Set the ASN we are searching for
	260	if (asn) {
	261	r = loc_database_enumerator_set_asn(enumerator, asn);
	262
	263	if (r) {
	264	PyErr_SetFromErrno(PyExc_SystemError);
	265	return NULL;
	266	}
	267	}
	268
bbdb2e0a MT	269	// Set the flags we are searching for
	270	if (flags) {
	271	r = loc_database_enumerator_set_flag(enumerator, flags);
	272
	273	if (r) {
	274	PyErr_SetFromErrno(PyExc_SystemError);
	275	return NULL;
	276	}
	277	}
	278
ccc7ab4e MT	279	PyObject* obj = new_database_enumerator(&DatabaseEnumeratorType, enumerator);
	280	loc_database_enumerator_unref(enumerator);
	281
	282	return obj;
	283	}
	284
9cdf6c53	285	static struct PyMethodDef Database_methods[] = {
86ca7ef7 MT	286	{
	287	"get_as",
	288	(PyCFunction)Database_get_as,
	289	METH_VARARGS,
	290	NULL,
	291	},
7c922e9c MT	292	{
	293	"get_country",
	294	(PyCFunction)Database_get_country,
	295	METH_VARARGS,
	296	NULL,
	297	},
31edab76 MT	298	{
	299	"lookup",
	300	(PyCFunction)Database_lookup,
	301	METH_VARARGS,
	302	NULL,
	303	},
afb426df MT	304	{
	305	"search_as",
	306	(PyCFunction)Database_search_as,
	307	METH_VARARGS,
	308	NULL,
	309	},
ccc7ab4e MT	310	{
	311	"search_networks",
	312	(PyCFunction)Database_search_networks,
	313	METH_VARARGS\|METH_KEYWORDS,
	314	NULL,
	315	},
b1720435 MT	316	{
	317	"verify",
	318	(PyCFunction)Database_verify,
726f9984	319	METH_VARARGS,
b1720435 MT	320	NULL,
b1720435 MT	321	},
9cdf6c53 MT	322	{ NULL },
	323	};
	324
d99b0256	325	static struct PyGetSetDef Database_getsetters[] = {
53524b2d MT	326	{
	327	"created_at",
	328	(getter)Database_get_created_at,
	329	NULL,
	330	NULL,
	331	NULL,
	332	},
d99b0256 MT	333	{
	334	"description",
	335	(getter)Database_get_description,
	336	NULL,
	337	NULL,
	338	NULL,
	339	},
4bf49d00 MT	340	{
	341	"license",
	342	(getter)Database_get_license,
	343	NULL,
	344	NULL,
	345	NULL,
	346	},
d99b0256 MT	347	{
	348	"vendor",
	349	(getter)Database_get_vendor,
	350	NULL,
	351	NULL,
53524b2d	352	NULL,
d99b0256 MT	353	},
	354	{ NULL },
	355	};
	356
9cdf6c53 MT	357	PyTypeObject DatabaseType = {
9cdf6c53 MT	358	PyVarObject_HEAD_INIT(NULL, 0)
d42e1dcd MT	359	.tp_name = "location.Database",
	360	.tp_basicsize = sizeof(DatabaseObject),
	361	.tp_flags = Py_TPFLAGS_DEFAULT\|Py_TPFLAGS_BASETYPE,
	362	.tp_new = Database_new,
	363	.tp_dealloc = (destructor)Database_dealloc,
	364	.tp_init = (initproc)Database_init,
	365	.tp_doc = "Database object",
	366	.tp_methods = Database_methods,
	367	.tp_getset = Database_getsetters,
	368	.tp_repr = (reprfunc)Database_repr,
9cdf6c53	369	};
afb426df MT	370
	371	static PyObject* DatabaseEnumerator_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
	372	DatabaseEnumeratorObject* self = (DatabaseEnumeratorObject*)type->tp_alloc(type, 0);
	373
	374	return (PyObject*)self;
	375	}
	376
	377	static void DatabaseEnumerator_dealloc(DatabaseEnumeratorObject* self) {
	378	loc_database_enumerator_unref(self->enumerator);
	379
	380	Py_TYPE(self)->tp_free((PyObject* )self);
	381	}
	382
	383	static PyObject* DatabaseEnumerator_next(DatabaseEnumeratorObject* self) {
15f79e2d MT	384	struct loc_network* network = NULL;
15f79e2d MT	385
ccc7ab4e	386	// Enumerate all networks
15f79e2d MT	387	int r = loc_database_enumerator_next_network(self->enumerator, &network);
15f79e2d MT	388	if (r) {
20bb6d0c	389	PyErr_SetFromErrno(PyExc_ValueError);
15f79e2d MT	390	return NULL;
	391	}
	392
	393	// A network was found
ccc7ab4e MT	394	if (network) {
	395	PyObject* obj = new_network(&NetworkType, network);
	396	loc_network_unref(network);
	397
	398	return obj;
	399	}
	400
	401	// Enumerate all ASes
15f79e2d MT	402	struct loc_as* as = NULL;
	403
	404	r = loc_database_enumerator_next_as(self->enumerator, &as);
	405	if (r) {
20bb6d0c	406	PyErr_SetFromErrno(PyExc_ValueError);
15f79e2d MT	407	return NULL;
	408	}
	409
afb426df MT	410	if (as) {
	411	PyObject* obj = new_as(&ASType, as);
	412	loc_as_unref(as);
	413
	414	return obj;
	415	}
	416
	417	// Nothing found, that means the end
	418	PyErr_SetNone(PyExc_StopIteration);
	419	return NULL;
	420	}
	421
	422	PyTypeObject DatabaseEnumeratorType = {
	423	PyVarObject_HEAD_INIT(NULL, 0)
d42e1dcd MT	424	.tp_name = "location.DatabaseEnumerator",
	425	.tp_basicsize = sizeof(DatabaseEnumeratorObject),
	426	.tp_flags = Py_TPFLAGS_DEFAULT,
	427	.tp_alloc = PyType_GenericAlloc,
	428	.tp_new = DatabaseEnumerator_new,
	429	.tp_dealloc = (destructor)DatabaseEnumerator_dealloc,
	430	.tp_iter = PyObject_SelfIter,
	431	.tp_iternext = (iternextfunc)DatabaseEnumerator_next,
afb426df	432	};