From 8c23f133c4a1cd58a83c837bcd8f77b739e87ff2 Mon Sep 17 00:00:00 2001 From: Tim Potter Date: Sat, 8 Apr 2006 00:40:52 +0000 Subject: r14968: Move tdb and ldb swig wrappers in to lib/tdb and lib/ldb directories. (This used to be commit fa8d0dc14a1af9567401d54a803b34a6498b7cd4) --- source4/lib/ldb/swig/Ldb.py | 102 +++++++++++++++++++++ source4/lib/ldb/swig/ldb.i | 219 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 321 insertions(+) create mode 100644 source4/lib/ldb/swig/Ldb.py create mode 100644 source4/lib/ldb/swig/ldb.i (limited to 'source4/lib/ldb/swig') diff --git a/source4/lib/ldb/swig/Ldb.py b/source4/lib/ldb/swig/Ldb.py new file mode 100644 index 0000000000..f761aec398 --- /dev/null +++ b/source4/lib/ldb/swig/Ldb.py @@ -0,0 +1,102 @@ +"""Provide a more Pythonic and object-oriented interface to ldb.""" + +# +# Swig interface to Samba +# +# Copyright (C) Tim Potter 2006 +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +# + +import ldb + +class LdbElement: + """A class representing a ldb element as an array of values.""" + + def __init__(self, elt): + self.name = elt.name + self.flags = elt.flags + self.values = [ldb.ldb_val_array_getitem(elt.values, x) + for x in range(elt.num_values)] + + def __repr__(self): + return '<%s(name=%s) instance at 0x%x' % (self.__class__.__name__, + `self.name`, id(self)) + + def __len__(self): + return self.values.len() + + def __getitem__(self, key): + return self.values[key] + +class LdbMessage: + """A class representing a ldb message as a dict of ldb elements.""" + + def __init__(self, msg = None): + + self.dn = None + self.private_data = None + self.elements = [] + + if msg is not None: + self.dn = msg.dn + self.private_data = msg.private_data + eltlist = \ + [LdbElement(ldb.ldb_message_element_array_getitem( + msg.elements, x)) + for x in range(msg.num_elements)] + self.elements = dict([(x.name, x) for x in eltlist]) + + def __repr__(self): + return '<%s(dn=%s) instance at 0x%x>' % (self.__class__.__name__, + `self.dn`, id(self)) + + def __getitem__(self, key): + return self.elements[key] + + def keys(self): + return self.elements.keys() + +class Ldb: + """A class representing a binding to a ldb file.""" + + def __init__(self): + self.mem_ctx = ldb.talloc_init('python ldb') + self.ldb_ctx = ldb.init(self.mem_ctx) + + def __del__(self): + ldb.talloc_free(self.mem_ctx) + + def connect(self, url, flags = 0): + ldb.connect(self.ldb_ctx, url, flags, None) + + def search(self, expression): + + result = ldb.search(self.ldb_ctx, None, ldb.LDB_SCOPE_DEFAULT, + expression, None); + + return [LdbMessage(ldb.ldb_message_ptr_array_getitem(result.msgs, ndx)) + for ndx in range(result.count)] + + def delete(self, dn): + if ldb.delete(self.ldb_ctx, dn) != 0: + raise IOError, ldb.errstring(self.ldb_ctx) + + def rename(self, olddn, newdn): + if ldb.rename(self.ldb_ctx, olddn, newdn) != 0: + raise IOError, ldb.errstring(self.ldb_ctx) + + def add(self, msg): + ldb.add(self.ldb_ctx, msg) diff --git a/source4/lib/ldb/swig/ldb.i b/source4/lib/ldb/swig/ldb.i new file mode 100644 index 0000000000..31c1ffe3e4 --- /dev/null +++ b/source4/lib/ldb/swig/ldb.i @@ -0,0 +1,219 @@ +/* + Unix SMB/CIFS implementation. + + Swig interface to ldb. + + Copyright (C) 2005,2006 Tim Potter + Copyright (C) 2006 Simo Sorce + + ** NOTE! The following LGPL license applies to the ldb + ** library. This does NOT imply that all of Samba is released + ** under the LGPL + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +*/ + +%module ldb + +%{ + +/* Some typedefs to help swig along */ + +typedef unsigned char uint8_t; +typedef unsigned long long uint64_t; +typedef long long int64_t; + +/* Include headers */ + +#include "lib/ldb/include/ldb.h" +#include "lib/talloc/talloc.h" + +%} + +%include "carrays.i" +%include "exception.i" + +/* + * Wrap struct ldb_context + */ + +/* The ldb functions will crash if a NULL ldb context is passed so + catch this before it happens. */ + +%typemap(check) struct ldb_context* { + if ($1 == NULL) + SWIG_exception(SWIG_ValueError, + "ldb context must be non-NULL"); +} + +/* + * Wrap TALLOC_CTX + */ + +/* Use talloc_init() to create a parameter to pass to ldb_init(). Don't + forget to free it using talloc_free() afterwards. */ + +TALLOC_CTX *talloc_init(char *name); +int talloc_free(TALLOC_CTX *ptr); + +/* + * Wrap struct ldb_val + */ + +%typemap(in) struct ldb_val { + if (!PyString_Check($input)) { + PyErr_SetString(PyExc_TypeError, "string arg expected"); + return NULL; + } + $1.length = PyString_Size($input); + $1.data = PyString_AsString($input); +} + +%typemap(out) struct ldb_val { + if ($1.data == NULL && $1.length == 0) { + $result = Py_None; + } else { + $result = PyString_FromStringAndSize($1.data, $1.length); + } +} + +enum ldb_scope {LDB_SCOPE_DEFAULT=-1, + LDB_SCOPE_BASE=0, + LDB_SCOPE_ONELEVEL=1, + LDB_SCOPE_SUBTREE=2}; + +/* + * Wrap struct ldb_result + */ + +%typemap(in, numinputs=0) struct ldb_result **OUT (struct ldb_result *temp_ldb_result) { + $1 = &temp_ldb_result; +} + +%typemap(argout) struct ldb_result ** { + + /* XXX: Check result for error and throw exception if necessary */ + + resultobj = SWIG_NewPointerObj(*$1, SWIGTYPE_p_ldb_result, 0); +} + +%types(struct ldb_result *); + +/* + * Wrap struct ldb_dn + */ + +%typemap(in) struct ldb_dn * { + if ($input == Py_None) { + $1 = NULL; + } else if (!PyString_Check($input)) { + PyErr_SetString(PyExc_TypeError, "string arg expected"); + return NULL; + } else { + $1 = ldb_dn_explode(NULL, PyString_AsString($input)); + } +} + +%typemap(out) struct ldb_dn * { + $result = PyString_FromString(ldb_dn_linearize($1, $1)); +} + +/* + * Wrap struct ldb_message_element + */ + +%array_functions(struct ldb_val, ldb_val_array); + +struct ldb_message_element { + unsigned int flags; + const char *name; + unsigned int num_values; + struct ldb_val *values; +}; + +/* + * Wrap struct ldb_message + */ + +%array_functions(struct ldb_message_element, ldb_message_element_array); + +struct ldb_message { + struct ldb_dn *dn; + unsigned int num_elements; + struct ldb_message_element *elements; + void *private_data; /* private to the backend */ +}; + +%typemap(in) struct ldb_message * { + PyObject *obj, *key, *value; + int pos; + + $1 = ldb_msg_new(NULL); + + obj = PyObject_GetAttrString($input, "dn"); + $1->dn = ldb_dn_explode(NULL, PyString_AsString(obj)); + + obj = PyObject_GetAttrString($input, "private_data"); + $1->private_data = PyString_AsString(obj); + + obj = PyObject_GetAttrString($input, "elements"); + + pos = 0; + while (PyDict_Next(obj, &pos, &key, &value)) { + struct ldb_val v; + + v.data = PyString_AsString(value); + v.length = PyString_Size(value); + ldb_msg_add_value($1, PyString_AsString(key), &v); + } +} + +/* + * Wrap struct ldb_result + */ + +%array_functions(struct ldb_message *, ldb_message_ptr_array); + +struct ldb_result { + unsigned int count; + struct ldb_message **msgs; + char **refs; + struct ldb_control **controls; +}; + +/* + * Wrap ldb functions + */ + +%rename ldb_init init; +struct ldb_context *ldb_init(TALLOC_CTX *mem_ctx); + +%rename ldb_errstring errstring; +const char *ldb_errstring(struct ldb_context *ldb); + +%rename ldb_connect connect; +int ldb_connect(struct ldb_context *ldb, const char *url, unsigned int flags, const char *options[]); + +%rename ldb_search search; +int ldb_search(struct ldb_context *ldb, const struct ldb_dn *base, enum ldb_scope scope, const char *expression, const char * const *attrs, struct ldb_result **OUT); + +%rename ldb_delete delete; +int ldb_delete(struct ldb_context *ldb, const struct ldb_dn *dn); + +%rename ldb_rename rename; +int ldb_rename(struct ldb_context *ldb, const struct ldb_dn *olddn, const struct ldb_dn *newdn); + +%rename ldb_add add; +int ldb_add(struct ldb_context *ldb, const struct ldb_message *message); -- cgit