[location/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) {
	struct loc_database_enumerator* enumerator;

	int r = loc_database_enumerator_new(&enumerator, self->db, what);
	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);
}

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

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