Line data    Source code

       1             : /* See https://www.python-ldap.org/ for details. */
       2             : 
       3             : #include "common.h"
       4             : #include "functions.h"
       5             : #include "LDAPObject.h"
       6             : #include "berval.h"
       7             : #include "constants.h"
       8             : #include "options.h"
       9             : 
      10             : /* ldap_initialize */
      11             : 
      12             : static PyObject*
      13         108 : l_ldap_initialize(PyObject* unused, PyObject *args)
      14             : {
      15             :     char *uri;
      16         108 :     LDAP *ld = NULL;
      17             :     int ret;
      18             : 
      19         108 :     if (!PyArg_ParseTuple(args, "s", &uri))
      20         108 :         return NULL;
      21             : 
      22         108 :     Py_BEGIN_ALLOW_THREADS
      23         108 :     ret = ldap_initialize(&ld, uri);
      24         108 :     Py_END_ALLOW_THREADS
      25         108 :     if (ret != LDAP_SUCCESS)
      26           0 :         return LDAPerror(ld, "ldap_initialize");
      27         108 :     return (PyObject*)newLDAPObject(ld);
      28             : }
      29             : 
      30             : 
      31             : /* ldap_str2dn */
      32             : 
      33             : static PyObject*
      34          32 : l_ldap_str2dn( PyObject* unused, PyObject *args )
      35             : {
      36             :     struct berval str;
      37             :     LDAPDN dn;
      38          32 :     int flags = 0;
      39          32 :     PyObject *result = NULL, *tmp;
      40             :     int res, i, j;
      41             :     Py_ssize_t str_len;
      42             : 
      43             :     /*
      44             :      * From a DN string such as "a=b,c=d;e=f", build
      45             :      * a list-equivalent of AVA structures; namely:
      46             :      * ((('a','b',1),('c','d',1)),(('e','f',1),))
      47             :      * The integers are a bit combination of the AVA_* flags
      48             :      */
      49          32 :     if (!PyArg_ParseTuple( args, "z#|i:str2dn", 
      50             :             &str.bv_val, &str_len, &flags )) 
      51          32 :         return NULL;
      52          32 :     str.bv_len = (ber_len_t) str_len;
      53             : 
      54          32 :     res = ldap_bv2dn(&str, &dn, flags);
      55          32 :     if (res != LDAP_SUCCESS)
      56           6 :         return LDAPerr(res);
      57             : 
      58          26 :     tmp = PyList_New(0);
      59          26 :     if (!tmp)
      60           0 :         goto failed;
      61             : 
      62          94 :     for (i = 0; dn[i]; i++) {
      63             :         LDAPRDN rdn;
      64             :         PyObject *rdnlist;
      65             : 
      66          68 :         rdn = dn[i];
      67          68 :         rdnlist = PyList_New(0);
      68          68 :         if (!rdnlist)
      69           0 :             goto failed;
      70          68 :         if (PyList_Append(tmp, rdnlist) == -1) {
      71           0 :             Py_DECREF(rdnlist);
      72           0 :             goto failed;
      73             :         }
      74             : 
      75         138 :         for (j = 0; rdn[j]; j++) {
      76          70 :             LDAPAVA *ava = rdn[j];
      77             :             PyObject *tuple;
      78             : 
      79          70 :             tuple = Py_BuildValue("(O&O&i)",
      80             :                 LDAPberval_to_unicode_object, &ava->la_attr,
      81             :                 LDAPberval_to_unicode_object, &ava->la_value,
      82          70 :                 ava->la_flags & ~(LDAP_AVA_FREE_ATTR|LDAP_AVA_FREE_VALUE));
      83          70 :             if (!tuple) {
      84           0 :                 Py_DECREF(rdnlist);
      85           0 :                 goto failed;
      86             :             }
      87             : 
      88          70 :             if (PyList_Append(rdnlist, tuple) == -1) {
      89           0 :                 Py_DECREF(tuple);
      90           0 :                 goto failed;
      91             :             }
      92          70 :             Py_DECREF(tuple);
      93             :         }
      94          68 :         Py_DECREF(rdnlist);
      95             :     }
      96             : 
      97          26 :     result = tmp;
      98          26 :     tmp = NULL;
      99             : 
     100          26 : failed:
     101          26 :     Py_XDECREF(tmp);
     102          26 :     ldap_dnfree(dn);
     103          26 :     return result;
     104             : }
     105             : 
     106             : /* ldap_set_option (global options) */
     107             : 
     108             : static PyObject*
     109          41 : l_ldap_set_option(PyObject* self, PyObject *args)
     110             : {
     111             :     PyObject *value;
     112             :     int option;
     113             : 
     114          41 :     if (!PyArg_ParseTuple(args, "iO:set_option", &option, &value))
     115          41 :         return NULL;
     116          41 :     if (!LDAP_set_option(NULL, option, value))
     117          14 :         return NULL;
     118          27 :     Py_INCREF(Py_None);
     119          27 :     return Py_None;
     120             : }
     121             : 
     122             : /* ldap_get_option (global options) */
     123             : 
     124             : static PyObject*
     125          46 : l_ldap_get_option(PyObject* self, PyObject *args)
     126             : {
     127             :     int option;
     128             : 
     129          46 :     if (!PyArg_ParseTuple(args, "i:get_option", &option))
     130          46 :         return NULL;
     131          46 :     return LDAP_get_option(NULL, option);
     132             : }
     133             : 
     134             : 
     135             : /* methods */
     136             : 
     137             : static PyMethodDef methods[] = {
     138             :     { "initialize",   (PyCFunction)l_ldap_initialize,         METH_VARARGS },
     139             :     { "str2dn",           (PyCFunction)l_ldap_str2dn,                 METH_VARARGS },
     140             :     { "set_option", (PyCFunction)l_ldap_set_option,           METH_VARARGS },
     141             :     { "get_option", (PyCFunction)l_ldap_get_option,           METH_VARARGS },
     142             :     { NULL, NULL }
     143             : };
     144             : 
     145             : /* initialisation */
     146             : 
     147             : void
     148           1 : LDAPinit_functions( PyObject* d ) {
     149           1 :     LDAPadd_methods( d, methods );
     150           1 : }