lib/talloc/pytalloc.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Python/Talloc glue
   4    Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program 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
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include <Python.h>
  21 #include "replace.h"
  22 #include <talloc.h>
  23 #include "pytalloc.h"
  24 #include <assert.h>
  25
  26 /**
  27  * Simple dealloc for talloc-wrapping PyObjects
  28  */
  29 void py_talloc_dealloc(PyObject* self)
  30 {
  31         py_talloc_Object *obj = (py_talloc_Object *)self;
  32         assert(talloc_unlink(NULL, obj->talloc_ctx) != -1);
  33         obj->talloc_ctx = NULL;
  34         self->ob_type->tp_free(self);
  35 }
  36
  37 /**
  38  * Import an existing talloc pointer into a Python object.
  39  */
  40 PyObject *py_talloc_steal_ex(PyTypeObject *py_type, TALLOC_CTX *mem_ctx,
  41                                                    void *ptr)
  42 {
  43         py_talloc_Object *ret = (py_talloc_Object *)py_type->tp_alloc(py_type, 0);
  44         ret->talloc_ctx = talloc_new(NULL);
  45         if (ret->talloc_ctx == NULL) {
  46                 return NULL;
  47         }
  48         if (talloc_steal(ret->talloc_ctx, mem_ctx) == NULL) {
  49                 return NULL;
  50         }
  51         talloc_set_name_const(ret->talloc_ctx, py_type->tp_name);
  52         ret->ptr = ptr;
  53         return (PyObject *)ret;
  54 }
  55
  56 /**
  57  * Import an existing talloc pointer into a Python object.
  58  */
  59 PyObject *py_talloc_steal(PyTypeObject *py_type, void *ptr)
  60 {
  61         return py_talloc_steal_ex(py_type, ptr, ptr);
  62 }
  63
  64
  65 /**
  66  * Import an existing talloc pointer into a Python object, leaving the
  67  * original parent, and creating a reference to the object in the python
  68  * object
  69  */
  70 PyObject *py_talloc_reference_ex(PyTypeObject *py_type, TALLOC_CTX *mem_ctx, void *ptr)
  71 {
  72         py_talloc_Object *ret;
  73
  74         if (ptr == NULL) {
  75                 Py_RETURN_NONE;
  76         }
  77
  78         ret = (py_talloc_Object *)py_type->tp_alloc(py_type, 0);
  79         ret->talloc_ctx = talloc_new(NULL);
  80         if (ret->talloc_ctx == NULL) {
  81                 return NULL;
  82         }
  83         if (talloc_reference(ret->talloc_ctx, mem_ctx) == NULL) {
  84                 return NULL;
  85         }
  86         talloc_set_name_const(ret->talloc_ctx, py_type->tp_name);
  87         ret->ptr = ptr;
  88         return (PyObject *)ret;
  89 }
  90
  91 /**
  92  * Default (but only slightly more useful than the default) implementation of Repr().
  93  */
  94 PyObject *py_talloc_default_repr(PyObject *obj)
  95 {
  96         py_talloc_Object *talloc_obj = (py_talloc_Object *)obj;
  97         PyTypeObject *type = (PyTypeObject*)PyObject_Type(obj);
  98
  99         return PyString_FromFormat("<%s talloc object at 0x%p>",
 100                                    type->tp_name, talloc_obj->ptr);
 101 }
 102
 103 /**
 104  * Default (but only slightly more useful than the default) implementation of cmp.
 105  */
 106 int py_talloc_default_cmp(PyObject *_obj1, PyObject *_obj2)
 107 {
 108         py_talloc_Object *obj1 = (py_talloc_Object *)_obj1,
 109                                          *obj2 = (py_talloc_Object *)_obj2;
 110         if (obj1->ob_type != obj2->ob_type)
 111                 return (obj1->ob_type - obj2->ob_type);
 112
 113         return ((char *)py_talloc_get_ptr(obj1) - (char *)py_talloc_get_ptr(obj2));
 114 }
 115
 116 static void py_cobject_talloc_free(void *ptr)
 117 {
 118         talloc_free(ptr);
 119 }
 120
 121 PyObject *PyCObject_FromTallocPtr(void *ptr)
 122 {
 123         if (ptr == NULL) {
 124                 Py_RETURN_NONE;
 125         }
 126         return PyCObject_FromVoidPtr(ptr, py_cobject_talloc_free);
 127 }
 128
 129 PyObject *PyString_FromString_check_null(const char *ptr)
 130 {
 131         if (ptr == NULL) {
 132                 Py_RETURN_NONE;
 133         }
 134         return PyString_FromString(ptr);
 135 }