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 PyObject* country_code_is_valid(PyObject* m, PyObject* args) {
  69         const char* country_code = NULL;
  70
  71         if (!PyArg_ParseTuple(args, "s", &country_code))
  72                 return NULL;
  73
  74         if (loc_country_code_is_valid(country_code))
  75                 Py_RETURN_TRUE;
  76
  77         Py_RETURN_FALSE;
  78 }
  79
  80 static PyMethodDef location_module_methods[] = {
  81         {
  82                 "country_code_is_valid",
  83                 (PyCFunction)country_code_is_valid,
  84                 METH_VARARGS,
  85                 NULL,
  86         },
  87         {
  88                 "discover_latest_version",
  89                 (PyCFunction)discover_latest_version,
  90                 METH_VARARGS,
  91                 NULL,
  92         },
  93         {
  94                 "set_log_level",
  95                 (PyCFunction)set_log_level,
  96                 METH_VARARGS,
  97                 NULL,
  98         },
  99         { NULL },
 100 };
 101
 102 static struct PyModuleDef location_module = {
 103         .m_base = PyModuleDef_HEAD_INIT,
 104         .m_name = "location",
 105         .m_size = -1,
 106         .m_doc = "Python module for libloc",
 107         .m_methods = location_module_methods,
 108         .m_free = (freefunc)location_free,
 109 };
 110
 111 PyMODINIT_FUNC PyInit_location(void) {
 112         // Initialise loc context
 113         int r = loc_new(&loc_ctx);
 114         if (r)
 115                 return NULL;
 116
 117         PyObject* m = PyModule_Create(&location_module);
 118         if (!m)
 119                 return NULL;
 120
 121         // AS
 122         if (PyType_Ready(&ASType) < 0)
 123                 return NULL;
 124
 125         Py_INCREF(&ASType);
 126         PyModule_AddObject(m, "AS", (PyObject *)&ASType);
 127
 128         // Country
 129         if (PyType_Ready(&CountryType) < 0)
 130                 return NULL;
 131
 132         Py_INCREF(&CountryType);
 133         PyModule_AddObject(m, "Country", (PyObject *)&CountryType);
 134
 135         // Database
 136         if (PyType_Ready(&DatabaseType) < 0)
 137                 return NULL;
 138
 139         Py_INCREF(&DatabaseType);
 140         PyModule_AddObject(m, "Database", (PyObject *)&DatabaseType);
 141
 142         // Database Enumerator
 143         if (PyType_Ready(&DatabaseEnumeratorType) < 0)
 144                 return NULL;
 145
 146         Py_INCREF(&DatabaseEnumeratorType);
 147         //PyModule_AddObject(m, "DatabaseEnumerator", (PyObject *)&DatabaseEnumeratorType);
 148
 149         // Network
 150         if (PyType_Ready(&NetworkType) < 0)
 151                 return NULL;
 152
 153         Py_INCREF(&NetworkType);
 154         PyModule_AddObject(m, "Network", (PyObject *)&NetworkType);
 155
 156         // Writer
 157         if (PyType_Ready(&WriterType) < 0)
 158                 return NULL;
 159
 160         Py_INCREF(&WriterType);
 161         PyModule_AddObject(m, "Writer", (PyObject *)&WriterType);
 162
 163         // Add constants
 164         if (PyModule_AddStringConstant(m, "__version__", VERSION))
 165                 return NULL;
 166
 167         // Add flags
 168         if (PyModule_AddIntConstant(m, "NETWORK_FLAG_ANONYMOUS_PROXY", LOC_NETWORK_FLAG_ANONYMOUS_PROXY))
 169                 return NULL;
 170
 171         if (PyModule_AddIntConstant(m, "NETWORK_FLAG_SATELLITE_PROVIDER", LOC_NETWORK_FLAG_SATELLITE_PROVIDER))
 172                 return NULL;
 173
 174         if (PyModule_AddIntConstant(m, "NETWORK_FLAG_ANYCAST", LOC_NETWORK_FLAG_ANYCAST))
 175                 return NULL;
 176
 177         return m;
 178 }