importer: Drop EDROP as it has been merged into DROP

[location/libloc.git] / src / python / database.c

diff --git a/src/python/database.c b/src/python/database.c
index f8bd94deebd1fb1e35b264cc362167d207afa4eb..d6ee4d02d0ed1d35fcf1ccc4244d25763e222cd3 100644 (file)
--- a/src/python/database.c
+++ b/src/python/database.c
@@ -16,10 +16,10 @@
 
 #include <Python.h>
 
-#include <loc/libloc.h>
-#include <loc/as.h>
-#include <loc/as-list.h>
-#include <loc/database.h>
+#include <libloc/libloc.h>
+#include <libloc/as.h>
+#include <libloc/as-list.h>
+#include <libloc/database.h>
 
 #include "locationmodule.h"
 #include "as.h"
@@ -45,28 +45,36 @@ static void Database_dealloc(DatabaseObject* self) {
 
 static int Database_init(DatabaseObject* self, PyObject* args, PyObject* kwargs) {
        const char* path = NULL;
+       FILE* f = NULL;
 
+       // Parse arguments
        if (!PyArg_ParseTuple(args, "s", &path))
                return -1;
 
+       // Copy path
        self->path = strdup(path);
+       if (!self->path)
+               goto ERROR;
 
        // Open the file for reading
-       FILE* f = fopen(self->path, "r");
-       if (!f) {
-               PyErr_SetFromErrno(PyExc_IOError);
-               return -1;
-       }
+       f = fopen(self->path, "r");
+       if (!f)
+               goto ERROR;
 
        // Load the database
        int r = loc_database_new(loc_ctx, &self->db, f);
-       fclose(f);
-
-       // Return on any errors
        if (r)
-               return -1;
+               goto ERROR;
 
+       fclose(f);
        return 0;
+
+ERROR:
+       if (f)
+               fclose(f);
+
+       PyErr_SetFromErrno(PyExc_OSError);
+       return -1;
 }
 
 static PyObject* Database_repr(DatabaseObject* self) {
@@ -103,18 +111,24 @@ static PyObject* Database_verify(DatabaseObject* self, PyObject* args) {
 
 static PyObject* Database_get_description(DatabaseObject* self) {
        const char* description = loc_database_get_description(self->db);
+       if (!description)
+               Py_RETURN_NONE;
 
        return PyUnicode_FromString(description);
 }
 
 static PyObject* Database_get_vendor(DatabaseObject* self) {
        const char* vendor = loc_database_get_vendor(self->db);
+       if (!vendor)
+               Py_RETURN_NONE;
 
        return PyUnicode_FromString(vendor);
 }
 
 static PyObject* Database_get_license(DatabaseObject* self) {
        const char* license = loc_database_get_license(self->db);
+       if (!license)
+               Py_RETURN_NONE;
 
        return PyUnicode_FromString(license);
 }
@@ -152,17 +166,32 @@ static PyObject* Database_get_as(DatabaseObject* self, PyObject* args) {
 }
 
 static PyObject* Database_get_country(DatabaseObject* self, PyObject* args) {
+       struct loc_country* country = NULL;
        const char* country_code = NULL;
 
        if (!PyArg_ParseTuple(args, "s", &country_code))
                return NULL;
 
-       struct loc_country* country;
+       // Fetch the country
        int r = loc_database_get_country(self->db, &country, country_code);
        if (r) {
-               Py_RETURN_NONE;
+               switch (errno) {
+                       case EINVAL:
+                               PyErr_SetString(PyExc_ValueError, "Invalid country code");
+                               break;
+
+                       default:
+                               PyErr_SetFromErrno(PyExc_OSError);
+                               break;
+               }
+
+               return NULL;
        }
 
+       // No result
+       if (!country)
+               Py_RETURN_NONE;
+
        PyObject* obj = new_country(&CountryType, country);
        loc_country_unref(country);
 
@@ -185,18 +214,21 @@ static PyObject* Database_lookup(DatabaseObject* self, PyObject* args) {
                loc_network_unref(network);
 
                return obj;
+       }
 
        // Nothing found
-       } else if (r == 1) {
+       if (!errno)
                Py_RETURN_NONE;
 
-       // Invalid input
-       } else if (r == -EINVAL) {
-               PyErr_Format(PyExc_ValueError, "Invalid IP address: %s", address);
-               return NULL;
+       // Handle any errors
+       switch (errno) {
+               case EINVAL:
+                       PyErr_Format(PyExc_ValueError, "Invalid IP address: %s", address);
+
+               default:
+                       PyErr_SetFromErrno(PyExc_OSError);
        }
 
-       // Unexpected error
        return NULL;
 }
 
@@ -347,7 +379,7 @@ static PyObject* Database_search_networks(DatabaseObject* self, PyObject* args,
                struct loc_as_list* asns;
                r = loc_as_list_new(loc_ctx, &asns);
                if (r) {
-                       PyErr_SetString(PyExc_SystemError, "Could not create AS list");
+                       PyErr_SetFromErrno(PyExc_OSError);
                        return NULL;
                }
 
@@ -366,7 +398,7 @@ static PyObject* Database_search_networks(DatabaseObject* self, PyObject* args,
                        struct loc_as* as;
                        r = loc_as_new(loc_ctx, &as, number);
                        if (r) {
-                               PyErr_SetString(PyExc_SystemError, "Could not create AS");
+                               PyErr_SetFromErrno(PyExc_OSError);
 
                                loc_as_list_unref(asns);
                                loc_as_unref(as);
@@ -375,7 +407,7 @@ static PyObject* Database_search_networks(DatabaseObject* self, PyObject* args,
 
                        r = loc_as_list_append(asns, as);
                        if (r) {
-                               PyErr_SetString(PyExc_SystemError, "Could not append AS to the list");
+                               PyErr_SetFromErrno(PyExc_OSError);
 
                                loc_as_list_unref(asns);
                                loc_as_unref(as);
@@ -387,7 +419,7 @@ static PyObject* Database_search_networks(DatabaseObject* self, PyObject* args,
 
                r = loc_database_enumerator_set_asns(enumerator, asns);
                if (r) {
-                       PyErr_SetFromErrno(PyExc_SystemError);
+                       PyErr_SetFromErrno(PyExc_OSError);
 
                        loc_as_list_unref(asns);
                        return NULL;
@@ -401,7 +433,7 @@ static PyObject* Database_search_networks(DatabaseObject* self, PyObject* args,
                r = loc_database_enumerator_set_flag(enumerator, flags);
 
                if (r) {
-                       PyErr_SetFromErrno(PyExc_SystemError);
+                       PyErr_SetFromErrno(PyExc_OSError);
                        return NULL;
                }
        }
@@ -411,7 +443,7 @@ static PyObject* Database_search_networks(DatabaseObject* self, PyObject* args,
                r = loc_database_enumerator_set_family(enumerator, family);
 
                if (r) {
-                       PyErr_SetFromErrno(PyExc_SystemError);
+                       PyErr_SetFromErrno(PyExc_OSError);
                        return NULL;
                }
        }
@@ -426,6 +458,17 @@ static PyObject* Database_countries(DatabaseObject* self) {
        return Database_iterate_all(self, LOC_DB_ENUMERATE_COUNTRIES, AF_UNSPEC, 0);
 }
 
+static PyObject* Database_list_bogons(DatabaseObject* self, PyObject* args, PyObject* kwargs) {
+       char* kwlist[] = { "family", NULL };
+       int family = AF_UNSPEC;
+
+       // Parse arguments
+       if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i", kwlist, &family))
+               return NULL;
+
+       return Database_iterate_all(self, LOC_DB_ENUMERATE_BOGONS, family, 0);
+}
+
 static struct PyMethodDef Database_methods[] = {
        {
                "get_as",
@@ -439,6 +482,12 @@ static struct PyMethodDef Database_methods[] = {
                METH_VARARGS,
                NULL,
        },
+       {
+               "list_bogons",
+               (PyCFunction)Database_list_bogons,
+               METH_VARARGS|METH_KEYWORDS,
+               NULL,
+       },
        {
                "lookup",
                (PyCFunction)Database_lookup,