src/python/network.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 <errno.h>
  20
  21 #include <loc/libloc.h>
  22 #include <loc/network.h>
  23
  24 #include "locationmodule.h"
  25 #include "network.h"
  26
  27 PyObject* new_network(PyTypeObject* type, struct loc_network* network) {
  28         NetworkObject* self = (NetworkObject*)type->tp_alloc(type, 0);
  29         if (self) {
  30                 self->network = loc_network_ref(network);
  31         }
  32
  33         return (PyObject*)self;
  34 }
  35
  36 static PyObject* Network_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
  37         NetworkObject* self = (NetworkObject*)type->tp_alloc(type, 0);
  38
  39         return (PyObject*)self;
  40 }
  41
  42 static void Network_dealloc(NetworkObject* self) {
  43         if (self->network)
  44                 loc_network_unref(self->network);
  45
  46         Py_TYPE(self)->tp_free((PyObject* )self);
  47 }
  48
  49 static int Network_init(NetworkObject* self, PyObject* args, PyObject* kwargs) {
  50         const char* network = NULL;
  51
  52         if (!PyArg_ParseTuple(args, "s", &network))
  53                 return -1;
  54
  55         // Load the Network
  56         int r = loc_network_new_from_string(loc_ctx, &self->network, network);
  57         if (r) {
  58                 PyErr_Format(PyExc_ValueError, "Invalid network: %s", network);
  59                 return -1;
  60         }
  61
  62         return 0;
  63 }
  64
  65 static PyObject* Network_repr(NetworkObject* self) {
  66         char* network = loc_network_str(self->network);
  67
  68         PyObject* obj = PyUnicode_FromFormat("<location.Network %s>", network);
  69         free(network);
  70
  71         return obj;
  72 }
  73
  74 static PyObject* Network_str(NetworkObject* self) {
  75         char* network = loc_network_str(self->network);
  76
  77         PyObject* obj = PyUnicode_FromString(network);
  78         free(network);
  79
  80         return obj;
  81 }
  82
  83 static PyObject* Network_get_country_code(NetworkObject* self) {
  84         const char* country_code = loc_network_get_country_code(self->network);
  85
  86         return PyUnicode_FromString(country_code);
  87 }
  88
  89 static int Network_set_country_code(NetworkObject* self, PyObject* value) {
  90         const char* country_code = PyUnicode_AsUTF8(value);
  91
  92         int r = loc_network_set_country_code(self->network, country_code);
  93         if (r) {
  94                 if (r == -EINVAL)
  95                         PyErr_Format(PyExc_ValueError,
  96                                 "Invalid country code: %s", country_code);
  97
  98                 return -1;
  99         }
 100
 101         return 0;
 102 }
 103
 104 static PyObject* Network_get_asn(NetworkObject* self) {
 105         uint32_t asn = loc_network_get_asn(self->network);
 106
 107         if (asn)
 108                 return PyLong_FromLong(asn);
 109
 110         Py_RETURN_NONE;
 111 }
 112
 113 static int Network_set_asn(NetworkObject* self, PyObject* value) {
 114         long int asn = PyLong_AsLong(value);
 115
 116         // Check if the ASN is within the valid range
 117         if (asn <= 0 || asn > UINT32_MAX) {
 118                 PyErr_Format(PyExc_ValueError, "Invalid ASN %ld", asn);
 119                 return -1;
 120         }
 121
 122         int r = loc_network_set_asn(self->network, asn);
 123         if (r)
 124                 return -1;
 125
 126         return 0;
 127 }
 128
 129 static struct PyGetSetDef Network_getsetters[] = {
 130         {
 131                 "asn",
 132                 (getter)Network_get_asn,
 133                 (setter)Network_set_asn,
 134                 NULL,
 135                 NULL,
 136         },
 137         {
 138                 "country_code",
 139                 (getter)Network_get_country_code,
 140                 (setter)Network_set_country_code,
 141                 NULL,
 142                 NULL,
 143         },
 144         { NULL },
 145 };
 146
 147 PyTypeObject NetworkType = {
 148         PyVarObject_HEAD_INIT(NULL, 0)
 149         tp_name:                "location.Network",
 150         tp_basicsize:           sizeof(NetworkObject),
 151         tp_flags:               Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
 152         tp_new:                 Network_new,
 153         tp_dealloc:             (destructor)Network_dealloc,
 154         tp_init:                (initproc)Network_init,
 155         tp_doc:                 "Network object",
 156         tp_getset:              Network_getsetters,
 157         tp_repr:                (reprfunc)Network_repr,
 158         tp_str:                 (reprfunc)Network_str,
 159 };