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 "lib/replace/system/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    89439375 : static PyTypeObject * PyLdb_GetPyType(const char *typename)
      36             : {
      37    89439375 :         PyTypeObject *type = NULL;
      38    76406437 :         bool ok;
      39             : 
      40    89439375 :         if (ldb_module == NULL) {
      41        3624 :                 ldb_module = PyImport_ImportModule("ldb");
      42        3624 :                 if (ldb_module == NULL) {
      43           0 :                         return NULL;
      44             :                 }
      45             :         }
      46             : 
      47    89439375 :         type = (PyTypeObject *)PyObject_GetAttrString(ldb_module, typename);
      48             : 
      49             : 
      50    89439375 :         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    89439375 :         ok = PyType_Check(type);
      58    89439375 :         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    13032938 :         return type;
      67             : }
      68             : 
      69    63190108 : bool pyldb_check_type(PyObject *obj, const char *typename)
      70             : {
      71    63190108 :         bool ok = false;
      72    63190108 :         PyTypeObject *type = PyLdb_GetPyType(typename);
      73    63190108 :         if (type != NULL) {
      74    63190108 :                 ok = PyObject_TypeCheck(obj, type);
      75    53989147 :                 Py_DECREF(type);
      76             :         }
      77    63190108 :         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     4533377 : bool pyldb_Object_AsDn(TALLOC_CTX *mem_ctx, PyObject *object, 
      89             :                    struct ldb_context *ldb_ctx, struct ldb_dn **dn)
      90             : {
      91     3767875 :         struct ldb_dn *odn;
      92     3767875 :         PyTypeObject *PyLdb_Dn_Type;
      93     3767875 :         bool is_dn;
      94             : 
      95     4533377 :         if (ldb_ctx != NULL && (PyUnicode_Check(object))) {
      96     1640580 :                 const char *odn_str = NULL;
      97             : 
      98     1640580 :                 odn_str = PyUnicode_AsUTF8(object);
      99     1640580 :                 if (odn_str == NULL) {
     100           0 :                         return false;
     101             :                 }
     102             : 
     103     1640580 :                 odn = ldb_dn_new(mem_ctx, ldb_ctx, odn_str);
     104     1640580 :                 if (odn == NULL) {
     105           0 :                         PyErr_NoMemory();
     106           0 :                         return false;
     107             :                 }
     108             : 
     109     1640580 :                 *dn = odn;
     110     1640580 :                 return true;
     111             :         }
     112             : 
     113     2892797 :         if (ldb_ctx != NULL && PyBytes_Check(object)) {
     114        2463 :                 const char *odn_str = NULL;
     115             : 
     116        2463 :                 odn_str = PyBytes_AsString(object);
     117        2463 :                 if (odn_str == NULL) {
     118           0 :                         return false;
     119             :                 }
     120             : 
     121        2463 :                 odn = ldb_dn_new(mem_ctx, ldb_ctx, odn_str);
     122        2463 :                 if (odn == NULL) {
     123           0 :                         PyErr_NoMemory();
     124           0 :                         return false;
     125             :                 }
     126             : 
     127        2463 :                 *dn = odn;
     128        2463 :                 return true;
     129             :         }
     130             : 
     131     2890334 :         PyLdb_Dn_Type = PyLdb_GetPyType("Dn");
     132     2890334 :         if (PyLdb_Dn_Type == NULL) {
     133           0 :                 PyErr_SetString(PyExc_TypeError, "Expected DN");
     134           0 :                 return false;
     135             :         }
     136             : 
     137     2890334 :         is_dn = PyObject_TypeCheck(object, PyLdb_Dn_Type);
     138     2366173 :         Py_DECREF(PyLdb_Dn_Type);
     139     2890334 :         if (is_dn) {
     140     2890332 :                 *dn = pyldb_Dn_AS_DN(object);
     141     2890332 :                 return true;
     142             :         }
     143             : 
     144           2 :         PyErr_SetString(PyExc_TypeError, "Expected DN");
     145           2 :         return false;
     146             : }
     147             : 
     148    23358944 : PyObject *pyldb_Dn_FromDn(struct ldb_dn *dn)
     149             : {
     150    23358944 :         TALLOC_CTX *mem_ctx = NULL;
     151    23358944 :         struct ldb_dn *dn_ref = NULL;
     152    20051128 :         PyLdbDnObject *py_ret;
     153    20051128 :         PyTypeObject *PyLdb_Dn_Type;
     154             : 
     155    23358944 :         if (dn == NULL) {
     156          11 :                 Py_RETURN_NONE;
     157             :         }
     158             : 
     159    23358933 :         mem_ctx = talloc_new(NULL);
     160    23358933 :         if (mem_ctx == NULL) {
     161           0 :                 return PyErr_NoMemory();
     162             :         }
     163             : 
     164    23358933 :         dn_ref = talloc_reference(mem_ctx, dn);
     165    23358933 :         if (dn_ref == NULL) {
     166           0 :                 talloc_free(mem_ctx);
     167           0 :                 return PyErr_NoMemory();
     168             :         }
     169             : 
     170    23358933 :         PyLdb_Dn_Type = PyLdb_GetPyType("Dn");
     171    23358933 :         if (PyLdb_Dn_Type == NULL) {
     172           0 :                 talloc_free(mem_ctx);
     173           0 :                 return NULL;
     174             :         }
     175             : 
     176    23358933 :         py_ret = (PyLdbDnObject *)PyLdb_Dn_Type->tp_alloc(PyLdb_Dn_Type, 0);
     177    20051117 :         Py_DECREF(PyLdb_Dn_Type);
     178    23358933 :         if (py_ret == NULL) {
     179           0 :                 talloc_free(mem_ctx);
     180           0 :                 PyErr_NoMemory();
     181           0 :                 return NULL;
     182             :         }
     183    23358933 :         py_ret->mem_ctx = mem_ctx;
     184    23358933 :         py_ret->dn = dn;
     185    23358933 :         return (PyObject *)py_ret;
     186             : }