src/python/as.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 <libloc/libloc.h>
  20 #include <libloc/as.h>
  21
  22 #include "locationmodule.h"
  23 #include "as.h"
  24
  25 PyObject* new_as(PyTypeObject* type, struct loc_as* as) {
  26         ASObject* self = (ASObject*)type->tp_alloc(type, 0);
  27         if (self) {
  28                 self->as = loc_as_ref(as);
  29         }
  30
  31         return (PyObject*)self;
  32 }
  33
  34 static PyObject* AS_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
  35         ASObject* self = (ASObject*)type->tp_alloc(type, 0);
  36
  37         return (PyObject*)self;
  38 }
  39
  40 static void AS_dealloc(ASObject* self) {
  41         if (self->as)
  42                 loc_as_unref(self->as);
  43
  44         Py_TYPE(self)->tp_free((PyObject* )self);
  45 }
  46
  47 static int AS_init(ASObject* self, PyObject* args, PyObject* kwargs) {
  48         uint32_t number = 0;
  49
  50         if (!PyArg_ParseTuple(args, "i", &number))
  51                 return -1;
  52
  53         // Create the AS object
  54         int r = loc_as_new(loc_ctx, &self->as, number);
  55         if (r)
  56                 return -1;
  57
  58         return 0;
  59 }
  60
  61 static PyObject* AS_repr(ASObject* self) {
  62         uint32_t number = loc_as_get_number(self->as);
  63         const char* name = loc_as_get_name(self->as);
  64
  65         if (name)
  66                 return PyUnicode_FromFormat("<AS %d (%s)>", number, name);
  67
  68         return PyUnicode_FromFormat("<AS %d>", number);
  69 }
  70
  71 static PyObject* AS_str(ASObject* self) {
  72         uint32_t number = loc_as_get_number(self->as);
  73         const char* name = loc_as_get_name(self->as);
  74
  75         if (name)
  76                 return PyUnicode_FromFormat("AS%d - %s", number, name);
  77
  78         return PyUnicode_FromFormat("AS%d", number);
  79 }
  80
  81 static PyObject* AS_get_number(ASObject* self) {
  82         uint32_t number = loc_as_get_number(self->as);
  83
  84         return PyLong_FromLong(number);
  85 }
  86
  87 static PyObject* AS_get_name(ASObject* self) {
  88         const char* name = loc_as_get_name(self->as);
  89
  90         return PyUnicode_FromString(name);
  91 }
  92
  93 static int AS_set_name(ASObject* self, PyObject* value) {
  94         const char* name = PyUnicode_AsUTF8(value);
  95
  96         int r = loc_as_set_name(self->as, name);
  97         if (r) {
  98                 PyErr_Format(PyExc_ValueError, "Could not set name: %s", name);
  99                 return r;
 100         }
 101
 102         return 0;
 103 }
 104
 105 static PyObject* AS_richcompare(ASObject* self, PyObject* other, int op) {
 106         int r;
 107
 108         // Check for type
 109         if (!PyObject_IsInstance(other, (PyObject *)&ASType))
 110                 Py_RETURN_NOTIMPLEMENTED;
 111
 112         ASObject* o = (ASObject*)other;
 113
 114         r = loc_as_cmp(self->as, o->as);
 115
 116         switch (op) {
 117                 case Py_EQ:
 118                         if (r == 0)
 119                                 Py_RETURN_TRUE;
 120
 121                         Py_RETURN_FALSE;
 122
 123                 case Py_LT:
 124                         if (r < 0)
 125                                 Py_RETURN_TRUE;
 126
 127                         Py_RETURN_FALSE;
 128
 129                 default:
 130                         break;
 131         }
 132
 133         Py_RETURN_NOTIMPLEMENTED;
 134 }
 135
 136 static Py_hash_t AS_hash(ASObject* self) {
 137         uint32_t number = loc_as_get_number(self->as);
 138
 139         return number;
 140 }
 141
 142 static struct PyGetSetDef AS_getsetters[] = {
 143         {
 144                 "name",
 145                 (getter)AS_get_name,
 146                 (setter)AS_set_name,
 147                 NULL,
 148                 NULL,
 149         },
 150         {
 151                 "number",
 152                 (getter)AS_get_number,
 153                 NULL,
 154                 NULL,
 155                 NULL,
 156         },
 157         { NULL },
 158 };
 159
 160 PyTypeObject ASType = {
 161         PyVarObject_HEAD_INIT(NULL, 0)
 162         .tp_name =               "location.AS",
 163         .tp_basicsize =          sizeof(ASObject),
 164         .tp_flags =              Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
 165         .tp_new =                AS_new,
 166         .tp_dealloc =            (destructor)AS_dealloc,
 167         .tp_init =               (initproc)AS_init,
 168         .tp_doc =                "AS object",
 169         .tp_getset =             AS_getsetters,
 170         .tp_repr =               (reprfunc)AS_repr,
 171         .tp_str =                (reprfunc)AS_str,
 172         .tp_richcompare =        (richcmpfunc)AS_richcompare,
 173         .tp_hash =               (hashfunc)AS_hash,
 174 };