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 "country.h"
  25 #include "database.h"
  26 #include "network.h"
  27
  28 static PyObject* Database_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
  29         DatabaseObject* self = (DatabaseObject*)type->tp_alloc(type, 0);
  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
  38         if (self->path)
  39                 free(self->path);
  40
  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
  50         self->path = strdup(path);
  51
  52         // Open the file for reading
  53         FILE* f = fopen(self->path, "r");
  54         if (!f) {
  55                 PyErr_SetFromErrno(PyExc_IOError);
  56                 return -1;
  57         }
  58
  59         // Load the database
  60         int r = loc_database_new(loc_ctx, &self->db, f);
  61         fclose(f);
  62
  63         // Return on any errors
  64         if (r)
  65                 return -1;
  66
  67         return 0;
  68 }
  69
  70 static PyObject* Database_repr(DatabaseObject* self) {
  71         return PyUnicode_FromFormat("<Database %s>", self->path);
  72 }
  73
  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);
  95
  96         if (r == 0)
  97                 Py_RETURN_TRUE;
  98
  99         Py_RETURN_FALSE;
 100 }
 101
 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
 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
 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
 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);
 135
 136         // We got an AS
 137         if (r == 0) {
 138                 PyObject* obj = new_as(&ASType, as);
 139                 loc_as_unref(as);
 140
 141                 return obj;
 142
 143         // Nothing found
 144         } else if (r == 1) {
 145                 Py_RETURN_NONE;
 146         }
 147
 148         // Unexpected error
 149         return NULL;
 150 }
 151
 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
 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;
 190
 191         // Invalid input
 192         } else if (r == -EINVAL) {
 193                 PyErr_Format(PyExc_ValueError, "Invalid IP address: %s", address);
 194                 return NULL;
 195         }
 196
 197         // Unexpected error
 198         return NULL;
 199 }
 200
 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_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
 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
 237         int r = loc_database_enumerator_new(&enumerator, self->db, LOC_DB_ENUMERATE_ASES);
 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
 252 static PyObject* Database_networks(DatabaseObject* self) {
 253         return Database_iterate_all(self, LOC_DB_ENUMERATE_NETWORKS);
 254 }
 255
 256 static PyObject* Database_search_networks(DatabaseObject* self, PyObject* args, PyObject* kwargs) {
 257         char* kwlist[] = { "country_code", "asn", "flags", "family", NULL };
 258         const char* country_code = NULL;
 259         unsigned int asn = 0;
 260         int flags = 0;
 261         int family = 0;
 262
 263         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|siii", kwlist, &country_code, &asn, &flags, &family))
 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
 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
 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
 313         PyObject* obj = new_database_enumerator(&DatabaseEnumeratorType, enumerator);
 314         loc_database_enumerator_unref(enumerator);
 315
 316         return obj;
 317 }
 318
 319 static struct PyMethodDef Database_methods[] = {
 320         {
 321                 "get_as",
 322                 (PyCFunction)Database_get_as,
 323                 METH_VARARGS,
 324                 NULL,
 325         },
 326         {
 327                 "get_country",
 328                 (PyCFunction)Database_get_country,
 329                 METH_VARARGS,
 330                 NULL,
 331         },
 332         {
 333                 "lookup",
 334                 (PyCFunction)Database_lookup,
 335                 METH_VARARGS,
 336                 NULL,
 337         },
 338         {
 339                 "search_as",
 340                 (PyCFunction)Database_search_as,
 341                 METH_VARARGS,
 342                 NULL,
 343         },
 344         {
 345                 "search_networks",
 346                 (PyCFunction)Database_search_networks,
 347                 METH_VARARGS|METH_KEYWORDS,
 348                 NULL,
 349         },
 350         {
 351                 "verify",
 352                 (PyCFunction)Database_verify,
 353                 METH_VARARGS,
 354                 NULL,
 355         },
 356         { NULL },
 357 };
 358
 359 static struct PyGetSetDef Database_getsetters[] = {
 360         {
 361                 "ases",
 362                 (getter)Database_ases,
 363                 NULL,
 364                 NULL,
 365                 NULL,
 366         },
 367         {
 368                 "created_at",
 369                 (getter)Database_get_created_at,
 370                 NULL,
 371                 NULL,
 372                 NULL,
 373         },
 374         {
 375                 "description",
 376                 (getter)Database_get_description,
 377                 NULL,
 378                 NULL,
 379                 NULL,
 380         },
 381         {
 382                 "license",
 383                 (getter)Database_get_license,
 384                 NULL,
 385                 NULL,
 386                 NULL,
 387         },
 388         {
 389                 "networks",
 390                 (getter)Database_networks,
 391                 NULL,
 392                 NULL,
 393                 NULL,
 394         },
 395         {
 396                 "vendor",
 397                 (getter)Database_get_vendor,
 398                 NULL,
 399                 NULL,
 400                 NULL,
 401         },
 402         { NULL },
 403 };
 404
 405 PyTypeObject DatabaseType = {
 406         PyVarObject_HEAD_INIT(NULL, 0)
 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,
 417 };
 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) {
 432         struct loc_network* network = NULL;
 433
 434         // Enumerate all networks
 435         int r = loc_database_enumerator_next_network(self->enumerator, &network);
 436         if (r) {
 437                 PyErr_SetFromErrno(PyExc_ValueError);
 438                 return NULL;
 439         }
 440
 441         // A network was found
 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
 450         struct loc_as* as = NULL;
 451
 452         r = loc_database_enumerator_next_as(self->enumerator, &as);
 453         if (r) {
 454                 PyErr_SetFromErrno(PyExc_ValueError);
 455                 return NULL;
 456         }
 457
 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)
 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,
 480 };