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