Line data    Source code

       1             : /*
       2             :    Unix SMB/CIFS implementation.
       3             : 
       4             :    Python interface to ldb - utility functions.
       5             : 
       6             :    Copyright (C) 2007-2010 Jelmer Vernooij <jelmer@samba.org>
       7             : 
       8             :          ** NOTE! The following LGPL license applies to the ldb
       9             :          ** library. This does NOT imply that all of Samba is released
      10             :          ** under the LGPL
      11             : 
      12             :    This library is free software; you can redistribute it and/or
      13             :    modify it under the terms of the GNU Lesser General Public
      14             :    License as published by the Free Software Foundation; either
      15             :    version 3 of the License, or (at your option) any later version.
      16             : 
      17             :    This library is distributed in the hope that it will be useful,
      18             :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      19             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      20             :    Lesser General Public License for more details.
      21             : 
      22             :    You should have received a copy of the GNU Lesser General Public
      23             :    License along with this library; if not, see <http://www.gnu.org/licenses/>.
      24             : */
      25             : 
      26             : #include <Python.h>
      27             : #include "ldb.h"
      28             : #include "pyldb.h"
      29             : 
      30             : static PyObject *ldb_module = NULL;
      31             : 
      32             : /**
      33             :  * Find out PyTypeObject in ldb module for a given typename
      34             :  */
      35    16202525 : static PyTypeObject * PyLdb_GetPyType(const char *typename)
      36             : {
      37    16202525 :         PyTypeObject *type = NULL;
      38    16202525 :         bool ok;
      39             : 
      40    16202525 :         if (ldb_module == NULL) {
      41        2239 :                 ldb_module = PyImport_ImportModule("ldb");
      42        2239 :                 if (ldb_module == NULL) {
      43             :                         return NULL;
      44             :                 }
      45             :         }
      46             : 
      47    16202525 :         type = (PyTypeObject *)PyObject_GetAttrString(ldb_module, typename);
      48             : 
      49             : 
      50    16202525 :         if (type == NULL) {
      51           0 :                 PyErr_Format(PyExc_NameError,
      52             :                              "Unable to find type %s in ldb module",
      53             :                              typename);
      54           0 :                 return NULL;
      55             :         }
      56             : 
      57    16202525 :         ok = PyType_Check(type);
      58    16202525 :         if (! ok) {
      59           0 :                 PyErr_Format(PyExc_TypeError,
      60             :                              "Expected type ldb.%s, not %s",
      61           0 :                              typename, Py_TYPE(type)->tp_name);
      62           0 :                 Py_DECREF(type);
      63           0 :                 return NULL;
      64             :         }
      65             : 
      66             :         return type;
      67             : }
      68             : 
      69        1216 : bool pyldb_check_type(PyObject *obj, const char *typename)
      70             : {
      71        1216 :         bool ok = false;
      72        1216 :         PyTypeObject *type = PyLdb_GetPyType(typename);
      73        1216 :         if (type != NULL) {
      74        1216 :                 ok = PyObject_TypeCheck(obj, type);
      75        1216 :                 Py_DECREF(type);
      76             :         }
      77        1216 :         return ok;
      78             : }
      79             : 
      80             : /**
      81             :  * Obtain a ldb DN from a Python object.
      82             :  *
      83             :  * @param mem_ctx Memory context
      84             :  * @param object Python object
      85             :  * @param ldb_ctx LDB context
      86             :  * @return Whether or not the conversion succeeded
      87             :  */
      88     3067669 : bool pyldb_Object_AsDn(TALLOC_CTX *mem_ctx, PyObject *object, 
      89             :                    struct ldb_context *ldb_ctx, struct ldb_dn **dn)
      90             : {
      91     3067669 :         struct ldb_dn *odn;
      92     3067669 :         PyTypeObject *PyLdb_Dn_Type;
      93             : 
      94     3067669 :         if (ldb_ctx != NULL && (PyUnicode_Check(object))) {
      95     1230879 :                 odn = ldb_dn_new(mem_ctx, ldb_ctx, PyUnicode_AsUTF8(object));
      96     1230879 :                 *dn = odn;
      97     1230879 :                 return true;
      98             :         }
      99             : 
     100     1835765 :         if (ldb_ctx != NULL && PyBytes_Check(object)) {
     101        2435 :                 odn = ldb_dn_new(mem_ctx, ldb_ctx, PyBytes_AsString(object));
     102        2435 :                 *dn = odn;
     103        2435 :                 return true;
     104             :         }
     105             : 
     106     1834355 :         PyLdb_Dn_Type = PyLdb_GetPyType("Dn");
     107     1834355 :         if (PyLdb_Dn_Type == NULL) {
     108             :                 return false;
     109             :         }
     110             : 
     111     1834355 :         if (PyObject_TypeCheck(object, PyLdb_Dn_Type)) {
     112     1834352 :                 *dn = pyldb_Dn_AS_DN(object);
     113     1834352 :                 return true;
     114             :         }
     115             : 
     116           3 :         PyErr_SetString(PyExc_TypeError, "Expected DN");
     117           3 :         return false;
     118             : }
     119             : 
     120    14366965 : PyObject *pyldb_Dn_FromDn(struct ldb_dn *dn)
     121             : {
     122    14366965 :         PyLdbDnObject *py_ret;
     123    14366965 :         PyTypeObject *PyLdb_Dn_Type;
     124             : 
     125    14366965 :         if (dn == NULL) {
     126          11 :                 Py_RETURN_NONE;
     127             :         }
     128             : 
     129    14366954 :         PyLdb_Dn_Type = PyLdb_GetPyType("Dn");
     130    14366954 :         if (PyLdb_Dn_Type == NULL) {
     131             :                 return NULL;
     132             :         }
     133             : 
     134    14366954 :         py_ret = (PyLdbDnObject *)PyLdb_Dn_Type->tp_alloc(PyLdb_Dn_Type, 0);
     135    14366954 :         if (py_ret == NULL) {
     136           0 :                 PyErr_NoMemory();
     137           0 :                 return NULL;
     138             :         }
     139    14366954 :         py_ret->mem_ctx = talloc_new(NULL);
     140    14366954 :         py_ret->dn = talloc_reference(py_ret->mem_ctx, dn);
     141    14366954 :         return (PyObject *)py_ret;
     142             : }