src/python/locationmodule.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 #include <syslog.h>
  19
  20 #include <loc/resolv.h>
  21
  22 #include "locationmodule.h"
  23 #include "as.h"
  24 #include "country.h"
  25 #include "database.h"
  26 #include "network.h"
  27 #include "writer.h"
  28
  29 /* Declare global context */
  30 struct loc_ctx* loc_ctx;
  31
  32 PyMODINIT_FUNC PyInit_location(void);
  33
  34 static void location_free(void) {
  35         // Release context
  36         if (loc_ctx)
  37                 loc_unref(loc_ctx);
  38 }
  39
  40 static PyObject* set_log_level(PyObject* m, PyObject* args) {
  41         int priority = LOG_INFO;
  42
  43         if (!PyArg_ParseTuple(args, "i", &priority))
  44                 return NULL;
  45
  46         loc_set_log_priority(loc_ctx, priority);
  47
  48         Py_RETURN_NONE;
  49 }
  50
  51 static PyObject* discover_latest_version(PyObject* m, PyObject* args) {
  52         const char* domain = NULL;
  53
  54         if (!PyArg_ParseTuple(args, "|s", &domain))
  55                 return NULL;
  56
  57         time_t t = 0;
  58
  59         int r = loc_discover_latest_version(loc_ctx, domain, &t);
  60         if (r) {
  61                 PyErr_SetFromErrno(PyExc_OSError);
  62                 return NULL;
  63         }
  64
  65         return PyLong_FromUnsignedLong(t);
  66 }
  67
  68 static PyMethodDef location_module_methods[] = {
  69         {
  70                 "discover_latest_version",
  71                 (PyCFunction)discover_latest_version,
  72                 METH_VARARGS,
  73                 NULL,
  74         },
  75         {
  76                 "set_log_level",
  77                 (PyCFunction)set_log_level,
  78                 METH_VARARGS,
  79                 NULL,
  80         },
  81         { NULL },
  82 };
  83
  84 static struct PyModuleDef location_module = {
  85         .m_base = PyModuleDef_HEAD_INIT,
  86         .m_name = "location",
  87         .m_size = -1,
  88         .m_doc = "Python module for libloc",
  89         .m_methods = location_module_methods,
  90         .m_free = (freefunc)location_free,
  91 };
  92
  93 PyMODINIT_FUNC PyInit_location(void) {
  94         // Initialise loc context
  95         int r = loc_new(&loc_ctx);
  96         if (r)
  97                 return NULL;
  98
  99         PyObject* m = PyModule_Create(&location_module);
 100         if (!m)
 101                 return NULL;
 102
 103         // AS
 104         if (PyType_Ready(&ASType) < 0)
 105                 return NULL;
 106
 107         Py_INCREF(&ASType);
 108         PyModule_AddObject(m, "AS", (PyObject *)&ASType);
 109
 110         // Country
 111         if (PyType_Ready(&CountryType) < 0)
 112                 return NULL;
 113
 114         Py_INCREF(&CountryType);
 115         PyModule_AddObject(m, "Country", (PyObject *)&CountryType);
 116
 117         // Database
 118         if (PyType_Ready(&DatabaseType) < 0)
 119                 return NULL;
 120
 121         Py_INCREF(&DatabaseType);
 122         PyModule_AddObject(m, "Database", (PyObject *)&DatabaseType);
 123
 124         // Database Enumerator
 125         if (PyType_Ready(&DatabaseEnumeratorType) < 0)
 126                 return NULL;
 127
 128         Py_INCREF(&DatabaseEnumeratorType);
 129         //PyModule_AddObject(m, "DatabaseEnumerator", (PyObject *)&DatabaseEnumeratorType);
 130
 131         // Network
 132         if (PyType_Ready(&NetworkType) < 0)
 133                 return NULL;
 134
 135         Py_INCREF(&NetworkType);
 136         PyModule_AddObject(m, "Network", (PyObject *)&NetworkType);
 137
 138         // Writer
 139         if (PyType_Ready(&WriterType) < 0)
 140                 return NULL;
 141
 142         Py_INCREF(&WriterType);
 143         PyModule_AddObject(m, "Writer", (PyObject *)&WriterType);
 144
 145         // Add constants
 146         if (PyModule_AddStringConstant(m, "__version__", VERSION))
 147                 return NULL;
 148
 149         // Add flags
 150         if (PyModule_AddIntConstant(m, "NETWORK_FLAG_ANONYMOUS_PROXY", LOC_NETWORK_FLAG_ANONYMOUS_PROXY))
 151                 return NULL;
 152
 153         if (PyModule_AddIntConstant(m, "NETWORK_FLAG_SATELLITE_PROVIDER", LOC_NETWORK_FLAG_SATELLITE_PROVIDER))
 154                 return NULL;
 155
 156         if (PyModule_AddIntConstant(m, "NETWORK_FLAG_ANYCAST", LOC_NETWORK_FLAG_ANYCAST))
 157                 return NULL;
 158
 159         return m;
 160 }