[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_iterate_all(DatabaseObject* self, enum loc_database_enumerator_mode what, int flags) {
	struct loc_database_enumerator* enumerator;

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

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

	return obj;
}

static PyObject* Database_ases(DatabaseObject* self) {
	return Database_iterate_all(self, LOC_DB_ENUMERATE_ASES, 0);
}

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, 0);
	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_networks(DatabaseObject* self) {
	return Database_iterate_all(self, LOC_DB_ENUMERATE_NETWORKS, 0);
}

static PyObject* Database_networks_flattened(DatabaseObject *self) {
	return Database_iterate_all(self, LOC_DB_ENUMERATE_NETWORKS, LOC_DB_ENUMERATOR_FLAGS_FLATTEN);
}

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, 0);
	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 PyObject* Database_countries(DatabaseObject* self) {
	return Database_iterate_all(self, LOC_DB_ENUMERATE_COUNTRIES, 0);
}

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[] = {
	{
		"ases",
		(getter)Database_ases,
		NULL,
		NULL,
		NULL,
	},
	{
		"countries",
		(getter)Database_countries,
		NULL,
		NULL,
		NULL,
	},
	{
		"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,
	},
	{
		"networks",
		(getter)Database_networks,
		NULL,
		NULL,
		NULL,
	},
	{
		"networks_flattened",
		(getter)Database_networks_flattened,
		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;
	}

	// Enumerate all countries
	struct loc_country* country = NULL;

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

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

		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
681ff05c	210	static PyObject* Database_iterate_all(DatabaseObject* self, enum loc_database_enumerator_mode what, int flags) {
a68a46f5 MT	211	struct loc_database_enumerator* enumerator;
a68a46f5 MT	212
681ff05c	213	int r = loc_database_enumerator_new(&enumerator, self->db, what, flags);
a68a46f5 MT	214	if (r) {
	215	PyErr_SetFromErrno(PyExc_SystemError);
	216	return NULL;
	217	}
	218
	219	PyObject* obj = new_database_enumerator(&DatabaseEnumeratorType, enumerator);
	220	loc_database_enumerator_unref(enumerator);
	221
	222	return obj;
	223	}
	224
	225	static PyObject* Database_ases(DatabaseObject* self) {
681ff05c	226	return Database_iterate_all(self, LOC_DB_ENUMERATE_ASES, 0);
a68a46f5 MT	227	}
a68a46f5 MT	228
afb426df MT	229	static PyObject* Database_search_as(DatabaseObject* self, PyObject* args) {
	230	const char* string = NULL;
	231
	232	if (!PyArg_ParseTuple(args, "s", &string))
	233	return NULL;
	234
	235	struct loc_database_enumerator* enumerator;
	236
681ff05c	237	int r = loc_database_enumerator_new(&enumerator, self->db, LOC_DB_ENUMERATE_ASES, 0);
afb426df MT	238	if (r) {
	239	PyErr_SetFromErrno(PyExc_SystemError);
	240	return NULL;
	241	}
	242
	243	// Search string we are searching for
	244	loc_database_enumerator_set_string(enumerator, string);
	245
	246	PyObject* obj = new_database_enumerator(&DatabaseEnumeratorType, enumerator);
	247	loc_database_enumerator_unref(enumerator);
	248
	249	return obj;
	250	}
	251
a68a46f5	252	static PyObject* Database_networks(DatabaseObject* self) {
681ff05c MT	253	return Database_iterate_all(self, LOC_DB_ENUMERATE_NETWORKS, 0);
	254	}
	255
	256	static PyObject* Database_networks_flattened(DatabaseObject *self) {
	257	return Database_iterate_all(self, LOC_DB_ENUMERATE_NETWORKS, LOC_DB_ENUMERATOR_FLAGS_FLATTEN);
a68a46f5 MT	258	}
a68a46f5 MT	259
ccc7ab4e	260	static PyObject* Database_search_networks(DatabaseObject* self, PyObject* args, PyObject* kwargs) {
44e5ef71	261	char* kwlist[] = { "country_code", "asn", "flags", "family", NULL };
ccc7ab4e MT	262	const char* country_code = NULL;
ccc7ab4e MT	263	unsigned int asn = 0;
bbdb2e0a	264	int flags = 0;
44e5ef71	265	int family = 0;
ccc7ab4e	266
44e5ef71	267	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "\|siii", kwlist, &country_code, &asn, &flags, &family))
ccc7ab4e MT	268	return NULL;
	269
	270	struct loc_database_enumerator* enumerator;
681ff05c	271	int r = loc_database_enumerator_new(&enumerator, self->db, LOC_DB_ENUMERATE_NETWORKS, 0);
ccc7ab4e MT	272	if (r) {
	273	PyErr_SetFromErrno(PyExc_SystemError);
	274	return NULL;
	275	}
	276
	277	// Set country code we are searching for
	278	if (country_code) {
	279	r = loc_database_enumerator_set_country_code(enumerator, country_code);
	280
	281	if (r) {
	282	PyErr_SetFromErrno(PyExc_SystemError);
	283	return NULL;
	284	}
	285	}
	286
	287	// Set the ASN we are searching for
	288	if (asn) {
	289	r = loc_database_enumerator_set_asn(enumerator, asn);
	290
	291	if (r) {
	292	PyErr_SetFromErrno(PyExc_SystemError);
	293	return NULL;
	294	}
	295	}
	296
bbdb2e0a MT	297	// Set the flags we are searching for
	298	if (flags) {
	299	r = loc_database_enumerator_set_flag(enumerator, flags);
	300
	301	if (r) {
	302	PyErr_SetFromErrno(PyExc_SystemError);
	303	return NULL;
	304	}
	305	}
	306
44e5ef71 MT	307	// Set the family we are searching for
	308	if (family) {
	309	r = loc_database_enumerator_set_family(enumerator, family);
	310
	311	if (r) {
	312	PyErr_SetFromErrno(PyExc_SystemError);
	313	return NULL;
	314	}
	315	}
	316
ccc7ab4e MT	317	PyObject* obj = new_database_enumerator(&DatabaseEnumeratorType, enumerator);
	318	loc_database_enumerator_unref(enumerator);
	319
	320	return obj;
	321	}
	322
fa9a3663	323	static PyObject* Database_countries(DatabaseObject* self) {
681ff05c	324	return Database_iterate_all(self, LOC_DB_ENUMERATE_COUNTRIES, 0);
fa9a3663 MT	325	}
fa9a3663 MT	326
9cdf6c53	327	static struct PyMethodDef Database_methods[] = {
86ca7ef7 MT	328	{
	329	"get_as",
	330	(PyCFunction)Database_get_as,
	331	METH_VARARGS,
	332	NULL,
	333	},
7c922e9c MT	334	{
	335	"get_country",
	336	(PyCFunction)Database_get_country,
	337	METH_VARARGS,
	338	NULL,
	339	},
31edab76 MT	340	{
	341	"lookup",
	342	(PyCFunction)Database_lookup,
	343	METH_VARARGS,
	344	NULL,
	345	},
afb426df MT	346	{
	347	"search_as",
	348	(PyCFunction)Database_search_as,
	349	METH_VARARGS,
	350	NULL,
	351	},
ccc7ab4e MT	352	{
	353	"search_networks",
	354	(PyCFunction)Database_search_networks,
	355	METH_VARARGS\|METH_KEYWORDS,
	356	NULL,
	357	},
b1720435 MT	358	{
	359	"verify",
	360	(PyCFunction)Database_verify,
726f9984	361	METH_VARARGS,
b1720435 MT	362	NULL,
b1720435 MT	363	},
9cdf6c53 MT	364	{ NULL },
	365	};
	366
d99b0256	367	static struct PyGetSetDef Database_getsetters[] = {
a68a46f5 MT	368	{
	369	"ases",
	370	(getter)Database_ases,
	371	NULL,
	372	NULL,
	373	NULL,
	374	},
fa9a3663 MT	375	{
	376	"countries",
	377	(getter)Database_countries,
	378	NULL,
	379	NULL,
	380	NULL,
	381	},
53524b2d MT	382	{
	383	"created_at",
	384	(getter)Database_get_created_at,
	385	NULL,
	386	NULL,
	387	NULL,
	388	},
d99b0256 MT	389	{
	390	"description",
	391	(getter)Database_get_description,
	392	NULL,
	393	NULL,
	394	NULL,
	395	},
4bf49d00 MT	396	{
	397	"license",
	398	(getter)Database_get_license,
	399	NULL,
	400	NULL,
	401	NULL,
	402	},
a68a46f5 MT	403	{
	404	"networks",
	405	(getter)Database_networks,
	406	NULL,
	407	NULL,
	408	NULL,
	409	},
681ff05c MT	410	{
	411	"networks_flattened",
	412	(getter)Database_networks_flattened,
	413	NULL,
	414	NULL,
	415	NULL,
	416	},
d99b0256 MT	417	{
	418	"vendor",
	419	(getter)Database_get_vendor,
	420	NULL,
	421	NULL,
53524b2d	422	NULL,
d99b0256 MT	423	},
	424	{ NULL },
	425	};
	426
9cdf6c53 MT	427	PyTypeObject DatabaseType = {
9cdf6c53 MT	428	PyVarObject_HEAD_INIT(NULL, 0)
d42e1dcd MT	429	.tp_name = "location.Database",
	430	.tp_basicsize = sizeof(DatabaseObject),
	431	.tp_flags = Py_TPFLAGS_DEFAULT\|Py_TPFLAGS_BASETYPE,
	432	.tp_new = Database_new,
	433	.tp_dealloc = (destructor)Database_dealloc,
	434	.tp_init = (initproc)Database_init,
	435	.tp_doc = "Database object",
	436	.tp_methods = Database_methods,
	437	.tp_getset = Database_getsetters,
	438	.tp_repr = (reprfunc)Database_repr,
9cdf6c53	439	};
afb426df MT	440
	441	static PyObject* DatabaseEnumerator_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
	442	DatabaseEnumeratorObject* self = (DatabaseEnumeratorObject*)type->tp_alloc(type, 0);
	443
	444	return (PyObject*)self;
	445	}
	446
	447	static void DatabaseEnumerator_dealloc(DatabaseEnumeratorObject* self) {
	448	loc_database_enumerator_unref(self->enumerator);
	449
	450	Py_TYPE(self)->tp_free((PyObject* )self);
	451	}
	452
	453	static PyObject* DatabaseEnumerator_next(DatabaseEnumeratorObject* self) {
15f79e2d MT	454	struct loc_network* network = NULL;
15f79e2d MT	455
ccc7ab4e	456	// Enumerate all networks
15f79e2d MT	457	int r = loc_database_enumerator_next_network(self->enumerator, &network);
15f79e2d MT	458	if (r) {
20bb6d0c	459	PyErr_SetFromErrno(PyExc_ValueError);
15f79e2d MT	460	return NULL;
	461	}
	462
	463	// A network was found
ccc7ab4e MT	464	if (network) {
	465	PyObject* obj = new_network(&NetworkType, network);
	466	loc_network_unref(network);
	467
	468	return obj;
	469	}
	470
	471	// Enumerate all ASes
15f79e2d MT	472	struct loc_as* as = NULL;
	473
	474	r = loc_database_enumerator_next_as(self->enumerator, &as);
	475	if (r) {
20bb6d0c	476	PyErr_SetFromErrno(PyExc_ValueError);
15f79e2d MT	477	return NULL;
	478	}
	479
afb426df MT	480	if (as) {
	481	PyObject* obj = new_as(&ASType, as);
	482	loc_as_unref(as);
	483
	484	return obj;
	485	}
	486
fa9a3663 MT	487	// Enumerate all countries
	488	struct loc_country* country = NULL;
	489
	490	r = loc_database_enumerator_next_country(self->enumerator, &country);
	491	if (r) {
	492	PyErr_SetFromErrno(PyExc_ValueError);
	493	return NULL;
	494	}
	495
	496	if (country) {
	497	PyObject* obj = new_country(&CountryType, country);
	498	loc_country_unref(country);
	499
	500	return obj;
	501	}
	502
afb426df MT	503	// Nothing found, that means the end
	504	PyErr_SetNone(PyExc_StopIteration);
	505	return NULL;
	506	}
	507
	508	PyTypeObject DatabaseEnumeratorType = {
	509	PyVarObject_HEAD_INIT(NULL, 0)
d42e1dcd MT	510	.tp_name = "location.DatabaseEnumerator",
	511	.tp_basicsize = sizeof(DatabaseEnumeratorObject),
	512	.tp_flags = Py_TPFLAGS_DEFAULT,
	513	.tp_alloc = PyType_GenericAlloc,
	514	.tp_new = DatabaseEnumerator_new,
	515	.tp_dealloc = (destructor)DatabaseEnumerator_dealloc,
	516	.tp_iter = PyObject_SelfIter,
	517	.tp_iternext = (iternextfunc)DatabaseEnumerator_next,
afb426df	518	};