src/python/database.c

   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
  19 #include <loc/libloc.h>
  20 #include <loc/database.h>
  21
  22 #include "locationmodule.h"
  23 #include "as.h"
  24 #include "database.h"
  25 #include "network.h"
  26
  27 static PyObject* Database_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
  28         DatabaseObject* self = (DatabaseObject*)type->tp_alloc(type, 0);
  29
  30         return (PyObject*)self;
  31 }
  32
  33 static void Database_dealloc(DatabaseObject* self) {
  34         if (self->db)
  35                 loc_database_unref(self->db);
  36
  37         if (self->path)
  38                 free(self->path);
  39
  40         Py_TYPE(self)->tp_free((PyObject* )self);
  41 }
  42
  43 static int Database_init(DatabaseObject* self, PyObject* args, PyObject* kwargs) {
  44         const char* path = NULL;
  45
  46         if (!PyArg_ParseTuple(args, "s", &path))
  47                 return -1;
  48
  49         self->path = strdup(path);
  50
  51         // Open the file for reading
  52         FILE* f = fopen(self->path, "r");
  53         if (!f)
  54                 return -1;
  55
  56         // Load the database
  57         int r = loc_database_new(loc_ctx, &self->db, f);
  58         fclose(f);
  59
  60         // Return on any errors
  61         if (r)
  62                 return -1;
  63
  64         return 0;
  65 }
  66
  67 static PyObject* Database_repr(DatabaseObject* self) {
  68         return PyUnicode_FromFormat("<Database %s>", self->path);
  69 }
  70
  71 static PyObject* Database_get_description(DatabaseObject* self) {
  72         const char* description = loc_database_get_description(self->db);
  73
  74         return PyUnicode_FromString(description);
  75 }
  76
  77 static PyObject* Database_get_vendor(DatabaseObject* self) {
  78         const char* vendor = loc_database_get_vendor(self->db);
  79
  80         return PyUnicode_FromString(vendor);
  81 }
  82
  83 static PyObject* Database_get_license(DatabaseObject* self) {
  84         const char* license = loc_database_get_license(self->db);
  85
  86         return PyUnicode_FromString(license);
  87 }
  88
  89 static PyObject* Database_get_created_at(DatabaseObject* self) {
  90         time_t created_at = loc_database_created_at(self->db);
  91
  92         return PyLong_FromLong(created_at);
  93 }
  94
  95 static PyObject* Database_get_as(DatabaseObject* self, PyObject* args) {
  96         struct loc_as* as = NULL;
  97         uint32_t number = 0;
  98
  99         if (!PyArg_ParseTuple(args, "i", &number))
 100                 return NULL;
 101
 102         // Try to retrieve the AS
 103         int r = loc_database_get_as(self->db, &as, number);
 104
 105         // We got an AS
 106         if (r == 0) {
 107                 PyObject* obj = new_as(&ASType, as);
 108                 loc_as_unref(as);
 109
 110                 return obj;
 111
 112         // Nothing found
 113         } else if (r == 1) {
 114                 Py_RETURN_NONE;
 115         }
 116
 117         // Unexpected error
 118         return NULL;
 119 }
 120
 121 static PyObject* Database_lookup(DatabaseObject* self, PyObject* args) {
 122         struct loc_network* network = NULL;
 123         const char* address = NULL;
 124
 125         if (!PyArg_ParseTuple(args, "s", &address))
 126                 return NULL;
 127
 128         // Try to retrieve a matching network
 129         int r = loc_database_lookup_from_string(self->db, address, &network);
 130
 131         // We got a network
 132         if (r == 0) {
 133                 PyObject* obj = new_network(&NetworkType, network);
 134                 loc_network_unref(network);
 135
 136                 return obj;
 137
 138         // Nothing found
 139         } else if (r == 1) {
 140                 Py_RETURN_NONE;
 141         }
 142
 143         // Unexpected error
 144         return NULL;
 145 }
 146
 147 static struct PyMethodDef Database_methods[] = {
 148         {
 149                 "get_as",
 150                 (PyCFunction)Database_get_as,
 151                 METH_VARARGS,
 152                 NULL,
 153         },
 154         {
 155                 "lookup",
 156                 (PyCFunction)Database_lookup,
 157                 METH_VARARGS,
 158                 NULL,
 159         },
 160         { NULL },
 161 };
 162
 163 static struct PyGetSetDef Database_getsetters[] = {
 164         {
 165                 "created_at",
 166                 (getter)Database_get_created_at,
 167                 NULL,
 168                 NULL,
 169                 NULL,
 170         },
 171         {
 172                 "description",
 173                 (getter)Database_get_description,
 174                 NULL,
 175                 NULL,
 176                 NULL,
 177         },
 178         {
 179                 "license",
 180                 (getter)Database_get_license,
 181                 NULL,
 182                 NULL,
 183                 NULL,
 184         },
 185         {
 186                 "vendor",
 187                 (getter)Database_get_vendor,
 188                 NULL,
 189                 NULL,
 190                 NULL,
 191         },
 192         { NULL },
 193 };
 194
 195 PyTypeObject DatabaseType = {
 196         PyVarObject_HEAD_INIT(NULL, 0)
 197         tp_name:                "location.Database",
 198         tp_basicsize:           sizeof(DatabaseObject),
 199         tp_flags:               Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
 200         tp_new:                 Database_new,
 201         tp_dealloc:             (destructor)Database_dealloc,
 202         tp_init:                (initproc)Database_init,
 203         tp_doc:                 "Database object",
 204         tp_methods:             Database_methods,
 205         tp_getset:              Database_getsetters,
 206         tp_repr:                (reprfunc)Database_repr,
 207 };