PyObject *set_obj,
unsigned int flags,
const char *attr_name);
+static PyTypeObject PyLdbBytesType;
#if PY_MAJOR_VERSION >= 3
#define PyStr_Check PyUnicode_Check
#define PyStr_AsUTF8 PyUnicode_AsUTF8
#define PyStr_AsUTF8AndSize PyUnicode_AsUTF8AndSize
#define PyInt_FromLong PyLong_FromLong
+
+#define PYARG_STR_UNI "es"
+
+static PyObject *PyLdbBytes_FromStringAndSize(const char *msg, int size)
+{
+ PyObject* result = NULL;
+ PyObject* args = NULL;
+ args = Py_BuildValue("(y#)", msg, size);
+ result = PyLdbBytesType.tp_new(&PyLdbBytesType, args, NULL);
+ Py_DECREF(args);
+ return result;
+}
#else
#define PyStr_Check PyString_Check
#define PyStr_FromString PyString_FromString
#define PyStr_FromFormat PyString_FromFormat
#define PyStr_FromFormatV PyString_FromFormatV
#define PyStr_AsUTF8 PyString_AsString
+#define PyLdbBytes_FromStringAndSize PyString_FromStringAndSize
+
+#define PYARG_STR_UNI "et"
const char *PyStr_AsUTF8AndSize(PyObject *pystr, Py_ssize_t *sizeptr);
const char *
}
static PyGetSetDef py_ldb_control_getset[] = {
- { discard_const_p(char, "oid"), (getter)py_ldb_control_get_oid, NULL, NULL },
- { discard_const_p(char, "critical"), (getter)py_ldb_control_get_critical, (setter)py_ldb_control_set_critical, NULL },
- { NULL }
+ {
+ .name = discard_const_p(char, "oid"),
+ .get = (getter)py_ldb_control_get_oid,
+ },
+ {
+ .name = discard_const_p(char, "critical"),
+ .get = (getter)py_ldb_control_get_critical,
+ .set = (setter)py_ldb_control_set_critical,
+ },
+ { .name = NULL },
};
static PyTypeObject PyLdbControl = {
Py_BuildValue(discard_const_p(char, "(i,s)"), ret,
ldb_ctx == NULL?ldb_strerror(ret):ldb_errstring(ldb_ctx)));
}
+static PyObject *py_ldb_bytes_str(PyBytesObject *self)
+{
+ char *msg = NULL;
+ Py_ssize_t size;
+ int result = 0;
+ if (!PyBytes_Check(self)) {
+ PyErr_Format(PyExc_TypeError,"Unexpected type");
+ return NULL;
+ }
+ result = PyBytes_AsStringAndSize((PyObject *)self, &msg, &size);
+ if (result != 0) {
+ PyErr_Format(PyExc_TypeError, "Failed to extract bytes");
+ return NULL;
+ }
+ return PyUnicode_FromStringAndSize(msg, size);
+}
+
+static PyTypeObject PyLdbBytesType = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ .tp_name = "ldb.bytes",
+ .tp_doc = "str/bytes (with custom str)",
+ .tp_str = (reprfunc)py_ldb_bytes_str,
+ .tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
+};
static PyObject *PyObject_FromLdbValue(const struct ldb_val *val)
{
- return PyBytes_FromStringAndSize((const char *)val->data, val->length);
+ return PyLdbBytes_FromStringAndSize((const char *)val->data, val->length);
}
static PyObject *PyStr_FromLdbValue(const struct ldb_val *val)
{
char *name;
int err;
- uint8_t *value;
+ uint8_t *value = NULL;
Py_ssize_t size = 0;
- if (!PyArg_ParseTuple(args, "sz#", &name, (const char**)&value, &size))
+ if (!PyArg_ParseTuple(args, "sz#", &name, (char **)&value, &size))
return NULL;
if (value == NULL) {
static PyObject *py_ldb_dn_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
- struct ldb_dn *ret;
- char *str;
- PyObject *py_ldb;
- struct ldb_context *ldb_ctx;
- TALLOC_CTX *mem_ctx;
- PyLdbDnObject *py_ret;
+ struct ldb_dn *ret = NULL;
+ char *str = NULL;
+ PyObject *py_ldb = NULL;
+ struct ldb_context *ldb_ctx = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+ PyLdbDnObject *py_ret = NULL;
const char * const kwnames[] = { "ldb", "dn", NULL };
- if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Os",
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O"PYARG_STR_UNI,
discard_const_p(char *, kwnames),
- &py_ldb, &str))
- return NULL;
+ &py_ldb, "utf8", &str))
+ goto out;
if (!PyLdb_Check(py_ldb)) {
PyErr_SetString(PyExc_TypeError, "Expected Ldb");
- return NULL;
+ goto out;
}
ldb_ctx = pyldb_Ldb_AsLdbContext(py_ldb);
mem_ctx = talloc_new(NULL);
if (mem_ctx == NULL) {
PyErr_NoMemory();
- return NULL;
+ goto out;
}
ret = ldb_dn_new(mem_ctx, ldb_ctx, str);
if (!ldb_dn_validate(ret)) {
talloc_free(mem_ctx);
PyErr_SetString(PyExc_ValueError, "unable to parse dn string");
- return NULL;
+ goto out;
}
py_ret = (PyLdbDnObject *)type->tp_alloc(type, 0);
- if (ret == NULL) {
+ if (py_ret == NULL) {
talloc_free(mem_ctx);
PyErr_NoMemory();
- return NULL;
+ goto out;
}
py_ret->mem_ctx = mem_ctx;
py_ret->dn = ret;
+out:
+ if (str != NULL) {
+ PyMem_Free(discard_const_p(char, str));
+ }
return (PyObject *)py_ret;
}
const char *str = NULL;
Py_ssize_t size;
PyObject *item = PyList_GetItem(list, i);
- if (!PyStr_Check(item)) {
+ if (!(PyStr_Check(item) || PyUnicode_Check(item))) {
PyErr_Format(PyExc_TypeError, "%s should be strings", paramname);
talloc_free(ret);
return NULL;
static PyObject *py_ldb_connect(PyLdbObject *self, PyObject *args, PyObject *kwargs)
{
- char *url;
+ char *url = NULL;
unsigned int flags = 0;
PyObject *py_options = Py_None;
int ret;
const char * const kwnames[] = { "url", "flags", "options", NULL };
struct ldb_context *ldb_ctx;
- if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|zIO",
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "z|IO",
discard_const_p(char *, kwnames),
&url, &flags, &py_options))
return NULL;
}
while (PyDict_Next(py_obj, &dict_pos, &key, &value)) {
- char *key_str = PyStr_AsUTF8(key);
+ const char *key_str = PyStr_AsUTF8(key);
if (ldb_attr_cmp(key_str, "dn") != 0) {
msg_el = PyObject_AsMessageElement(msg->elements, value,
mod_flags, key_str);
Py_RETURN_NONE;
} else {
/* We don't want this attached to the 'ldb' any more */
- return Py_BuildValue(discard_const_p(char, "(iO)"),
- ldif->changetype,
- PyLdbMessage_FromMessage(ldif->msg));
+ PyObject *obj = PyLdbMessage_FromMessage(ldif->msg);
+ PyObject *result =
+ Py_BuildValue(discard_const_p(char, "(iO)"),
+ ldif->changetype,
+ obj);
+ Py_CLEAR(obj);
+ return result;
}
}
PyObject *list, *ret;
struct ldb_ldif *ldif;
const char *s;
+ struct ldb_dn *last_dn = NULL;
TALLOC_CTX *mem_ctx;
ldif = ldb_ldif_read_string(self->ldb_ctx, &s);
talloc_steal(mem_ctx, ldif);
if (ldif) {
- PyList_Append(list, ldb_ldif_to_pyobject(ldif));
+ int res = 0;
+ PyObject *py_ldif = ldb_ldif_to_pyobject(ldif);
+ if (py_ldif == NULL) {
+ Py_CLEAR(list);
+ PyErr_BadArgument();
+ talloc_free(mem_ctx);
+ return NULL;
+ }
+ res = PyList_Append(list, py_ldif);
+ Py_CLEAR(py_ldif);
+ if (res == -1) {
+ Py_CLEAR(list);
+ talloc_free(mem_ctx);
+ return NULL;
+ }
+ last_dn = ldif->msg->dn;
} else {
- PyErr_SetString(PyExc_ValueError, "unable to parse ldif string");
+ const char *last_dn_str = NULL;
+ const char *err_string = NULL;
+ if (last_dn == NULL) {
+ PyErr_SetString(PyExc_ValueError,
+ "unable to parse LDIF "
+ "string at first chunk");
+ Py_CLEAR(list);
+ talloc_free(mem_ctx);
+ return NULL;
+ }
+
+ last_dn_str
+ = ldb_dn_get_linearized(last_dn);
+
+ err_string
+ = talloc_asprintf(mem_ctx,
+ "unable to parse ldif "
+ "string AFTER %s",
+ last_dn_str);
+
+ PyErr_SetString(PyExc_ValueError,
+ err_string);
talloc_free(mem_ctx);
+ Py_CLEAR(list);
return NULL;
}
}
PyObject *ret = PyList_New(0);
struct ldb_module *mod;
+ if (ret == NULL) {
+ return PyErr_NoMemory();
+ }
for (mod = ldb->modules; mod; mod = mod->next) {
- PyList_Append(ret, PyLdbModule_FromModule(mod));
+ PyObject *item = PyLdbModule_FromModule(mod);
+ int res = 0;
+ if (item == NULL) {
+ PyErr_SetString(PyExc_RuntimeError,
+ "Failed to load LdbModule");
+ Py_CLEAR(ret);
+ return NULL;
+ }
+ res = PyList_Append(ret, item);
+ Py_CLEAR(item);
+ if (res == -1) {
+ Py_CLEAR(ret);
+ return NULL;
+ }
}
return ret;
}
static PyGetSetDef py_ldb_getset[] = {
- { discard_const_p(char, "firstmodule"), (getter)py_ldb_get_firstmodule, NULL, NULL },
- { NULL }
+ {
+ .name = discard_const_p(char, "firstmodule"),
+ .get = (getter)py_ldb_get_firstmodule,
+ },
+ { .name = NULL },
};
static int py_ldb_contains(PyLdbObject *self, PyObject *obj)
}
static PyGetSetDef py_ldb_result_getset[] = {
- { discard_const_p(char, "controls"), (getter)py_ldb_result_get_controls, NULL, NULL },
- { discard_const_p(char, "msgs"), (getter)py_ldb_result_get_msgs, NULL, NULL },
- { discard_const_p(char, "referals"), (getter)py_ldb_result_get_referals, NULL, NULL },
- { discard_const_p(char, "count"), (getter)py_ldb_result_get_count, NULL, NULL },
- { NULL }
+ {
+ .name = discard_const_p(char, "controls"),
+ .get = (getter)py_ldb_result_get_controls,
+ },
+ {
+ .name = discard_const_p(char, "msgs"),
+ .get = (getter)py_ldb_result_get_msgs,
+ },
+ {
+ .name = discard_const_p(char, "referals"),
+ .get = (getter)py_ldb_result_get_referals,
+ },
+ {
+ .name = discard_const_p(char, "count"),
+ .get = (getter)py_ldb_result_get_count,
+ },
+ { .name = NULL },
};
static PyObject *py_ldb_result_iter(PyLdbResultObject *self)
me->name = talloc_strdup(me, attr_name);
me->flags = flags;
- if (PyBytes_Check(set_obj) || PyStr_Check(set_obj)) {
+ if (PyBytes_Check(set_obj) || PyUnicode_Check(set_obj)) {
me->num_values = 1;
me->values = talloc_array(me, struct ldb_val, me->num_values);
if (PyBytes_Check(set_obj)) {
return NULL;
}
msg = _msg;
- } else if (PyStr_Check(obj)) {
+ } else if (PyUnicode_Check(obj)) {
msg = PyStr_AsUTF8AndSize(obj, &size);
if (msg == NULL) {
talloc_free(me);
PyErr_SetString(PyExc_IndexError, "Out of range");
return NULL;
}
- return PyBytes_FromStringAndSize((char *)el->values[idx].data, el->values[idx].length);
+ return PyLdbBytes_FromStringAndSize((char *)el->values[idx].data, el->values[idx].length);
}
static PySequenceMethods py_ldb_msg_element_seq = {
if (py_elements != NULL) {
Py_ssize_t i;
- if (PyBytes_Check(py_elements)) {
+ if (PyBytes_Check(py_elements) || PyUnicode_Check(py_elements)) {
char *_msg = NULL;
el->num_values = 1;
el->values = talloc_array(el, struct ldb_val, 1);
PyErr_NoMemory();
return NULL;
}
- result = PyBytes_AsStringAndSize(py_elements, &_msg, &size);
+ if (PyBytes_Check(py_elements)) {
+ result = PyBytes_AsStringAndSize(py_elements, &_msg, &size);
+ msg = _msg;
+ } else {
+ msg = PyStr_AsUTF8AndSize(py_elements, &size);
+ result = (msg == NULL) ? -1 : 0;
+ }
if (result != 0) {
talloc_free(mem_ctx);
return NULL;
}
- msg = _msg;
el->values[0].data = talloc_memdup(el->values,
(const uint8_t *)msg, size + 1);
el->values[0].length = size;
char *_msg = NULL;
result = PyBytes_AsStringAndSize(item, &_msg, &size);
msg = _msg;
- } else if (PyStr_Check(item)) {
+ } else if (PyUnicode_Check(item)) {
msg = PyStr_AsUTF8AndSize(item, &size);
result = (msg == NULL) ? -1 : 0;
} else {
}
static PyGetSetDef py_ldb_msg_element_getset[] = {
- { discard_const_p(char, "text"), (getter)py_ldb_msg_element_get_text, NULL, NULL },
- { NULL }
+ {
+ .name = discard_const_p(char, "text"),
+ .get = (getter)py_ldb_msg_element_get_text,
+ },
+ { .name = NULL }
};
static PyTypeObject PyLdbMessageElement = {
static PyObject *py_ldb_msg_getitem_helper(PyLdbMessageObject *self, PyObject *py_name)
{
struct ldb_message_element *el;
- char *name;
+ const char *name;
struct ldb_message *msg = pyldb_Message_AsMessage(self);
name = PyStr_AsUTF8(py_name);
if (name == NULL) {
struct ldb_message *msg = pyldb_Message_AsMessage(self);
Py_ssize_t i, j = 0;
PyObject *l = PyList_New(msg->num_elements + (msg->dn == NULL?0:1));
+ if (l == NULL) {
+ return PyErr_NoMemory();
+ }
if (msg->dn != NULL) {
- PyList_SetItem(l, 0, Py_BuildValue("(sO)", "dn", pyldb_Dn_FromDn(msg->dn)));
+ PyObject *value = NULL;
+ PyObject *obj = pyldb_Dn_FromDn(msg->dn);
+ int res = 0;
+ value = Py_BuildValue("(sO)", "dn", obj);
+ Py_CLEAR(obj);
+ if (value == NULL) {
+ Py_CLEAR(l);
+ return NULL;
+ }
+ res = PyList_SetItem(l, 0, value);
+ if (res == -1) {
+ Py_CLEAR(l);
+ return NULL;
+ }
j++;
}
for (i = 0; i < msg->num_elements; i++, j++) {
+ PyObject *value = NULL;
PyObject *py_el = PyLdbMessageElement_FromMessageElement(&msg->elements[i], msg->elements);
- PyObject *value = Py_BuildValue("(sO)", msg->elements[i].name, py_el);
- PyList_SetItem(l, j, value);
+ int res = 0;
+ Py_CLEAR(py_el);
+ value = Py_BuildValue("(sO)", msg->elements[i].name, py_el);
+ if (value == NULL ) {
+ Py_CLEAR(l);
+ return NULL;
+ }
+ res = PyList_SetItem(l, 0, value);
+ if (res == -1) {
+ Py_CLEAR(l);
+ return NULL;
+ }
}
return l;
}
PyErr_SetString(PyExc_ValueError, "Invalid MessageElement object");
return NULL;
}
-
+ if (el->name == NULL) {
+ PyErr_SetString(PyExc_ValueError,
+ "The element has no name");
+ return NULL;
+ }
ret = ldb_msg_add_empty(msg, el->name, el->flags, &el_new);
PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, NULL);
static int py_ldb_msg_setitem(PyLdbMessageObject *self, PyObject *name, PyObject *value)
{
- char *attr_name;
+ const char *attr_name;
attr_name = PyStr_AsUTF8(name);
if (attr_name == NULL) {
}
static PyGetSetDef py_ldb_msg_getset[] = {
- { discard_const_p(char, "dn"), (getter)py_ldb_msg_get_dn, (setter)py_ldb_msg_set_dn, NULL },
- { discard_const_p(char, "text"), (getter)py_ldb_msg_get_text, NULL, NULL },
- { NULL }
+ {
+ .name = discard_const_p(char, "dn"),
+ .get = (getter)py_ldb_msg_get_dn,
+ .set = (setter)py_ldb_msg_set_dn,
+ },
+ {
+ .name = discard_const_p(char, "text"),
+ .get = (getter)py_ldb_msg_get_text,
+ },
+ { .name = NULL },
};
static PyObject *py_ldb_msg_repr(PyLdbMessageObject *self)
int ret;
struct ldb_module_ops *ops;
PyObject *input;
+ PyObject *tmp;
if (!PyArg_ParseTuple(args, "O", &input))
return NULL;
- ops = talloc_zero(talloc_autofree_context(), struct ldb_module_ops);
+ ops = talloc_zero(NULL, struct ldb_module_ops);
if (ops == NULL) {
PyErr_NoMemory();
return NULL;
}
- ops->name = talloc_strdup(ops, PyStr_AsUTF8(PyObject_GetAttrString(input, discard_const_p(char, "name"))));
+ tmp = PyObject_GetAttrString(input, discard_const_p(char, "name"));
+ ops->name = talloc_strdup(ops, PyStr_AsUTF8(tmp));
+ Py_XDECREF(tmp);
Py_INCREF(input);
ops->private_data = input;
ops->init_context = py_module_init;
ops->del_transaction = py_module_del_transaction;
ret = ldb_register_module(ops);
+ if (ret != LDB_SUCCESS) {
+ TALLOC_FREE(ops);
+ }
PyErr_LDB_ERROR_IS_ERR_RAISE(PyExc_LdbError, ret, NULL);
{
PyObject *m;
+ PyLdbBytesType.tp_base = &PyBytes_Type;
+ if (PyType_Ready(&PyLdbBytesType) < 0) {
+ return NULL;
+ }
+
if (PyType_Ready(&PyLdbDn) < 0)
return NULL;
ADD_LDB_INT(FLAG_MOD_REPLACE);
ADD_LDB_INT(FLAG_MOD_DELETE);
+ ADD_LDB_INT(ATTR_FLAG_HIDDEN);
+ ADD_LDB_INT(ATTR_FLAG_UNIQUE_INDEX);
+ ADD_LDB_INT(ATTR_FLAG_SINGLE_VALUE);
+ ADD_LDB_INT(ATTR_FLAG_FORCE_BASE64_LDIF);
+
ADD_LDB_INT(SUCCESS);
ADD_LDB_INT(ERR_OPERATIONS_ERROR);
ADD_LDB_INT(ERR_PROTOCOL_ERROR);
ADD_LDB_INT(FLG_NOSYNC);
ADD_LDB_INT(FLG_RECONNECT);
ADD_LDB_INT(FLG_NOMMAP);
+ ADD_LDB_INT(FLG_SHOW_BINARY);
+ ADD_LDB_INT(FLG_ENABLE_TRACING);
+ ADD_LDB_INT(FLG_DONT_CREATE_DB);
+
/* Historical misspelling */
PyModule_AddIntConstant(m, "ERR_ALIAS_DEREFERINCING_PROBLEM", LDB_ERR_ALIAS_DEREFERENCING_PROBLEM);
ADD_LDB_STRING(SYNTAX_DN);
ADD_LDB_STRING(SYNTAX_DIRECTORY_STRING);
ADD_LDB_STRING(SYNTAX_INTEGER);
+ ADD_LDB_STRING(SYNTAX_ORDERED_INTEGER);
ADD_LDB_STRING(SYNTAX_BOOLEAN);
ADD_LDB_STRING(SYNTAX_OCTET_STRING);
ADD_LDB_STRING(SYNTAX_UTC_TIME);