static PyObject *py_dsdb_convert_schema_to_openldap(PyObject *self, PyObject *args) { char *target_str, *mapping; PyObject *py_ldb; struct ldb_context *ldb; PyObject *ret; char *retstr; if (!PyArg_ParseTuple(args, "Oss", &py_ldb, &target_str, &mapping)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); retstr = dsdb_convert_schema_to_openldap(ldb, target_str, mapping); if (retstr == NULL) { PyErr_SetString(PyExc_RuntimeError, "dsdb_convert_schema_to_openldap failed"); return NULL; } ret = PyString_FromString(retstr); talloc_free(retstr); return ret; }
static PyObject *py_samdb_ntds_invocation_id(PyObject *self, PyObject *args) { PyObject *py_ldb, *result; struct ldb_context *ldb; const struct GUID *guid; char *retstr; if (!PyArg_ParseTuple(args, "O", &py_ldb)) { return NULL; } PyErr_LDB_OR_RAISE(py_ldb, ldb); guid = samdb_ntds_invocation_id(ldb); if (guid == NULL) { PyErr_SetString(PyExc_RuntimeError, "Failed to find NTDS invocation ID"); return NULL; } retstr = GUID_string(NULL, guid); if (retstr == NULL) { PyErr_NoMemory(); return NULL; } result = PyString_FromString(retstr); talloc_free(retstr); return result; }
static PyObject *py_samdb_set_ntds_settings_dn(PyLdbObject *self, PyObject *args) { PyObject *py_ldb, *py_ntds_settings_dn; struct ldb_context *ldb; struct ldb_dn *ntds_settings_dn; TALLOC_CTX *tmp_ctx; bool ret; if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_ntds_settings_dn)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); tmp_ctx = talloc_new(NULL); if (tmp_ctx == NULL) { PyErr_NoMemory(); return NULL; } if (!pyldb_Object_AsDn(tmp_ctx, py_ntds_settings_dn, ldb, &ntds_settings_dn)) { /* exception thrown by "pyldb_Object_AsDn" */ talloc_free(tmp_ctx); return NULL; } ret = samdb_set_ntds_settings_dn(ldb, ntds_settings_dn); talloc_free(tmp_ctx); if (!ret) { PyErr_SetString(PyExc_RuntimeError, "set_ntds_settings_dn failed"); return NULL; } Py_RETURN_NONE; }
/* return the linkID from the attribute name */ static PyObject *py_dsdb_get_linkId_from_lDAPDisplayName(PyObject *self, PyObject *args) { PyObject *py_ldb; struct ldb_context *ldb; struct dsdb_schema *schema; const char *ldap_display_name; const struct dsdb_attribute *attribute; if (!PyArg_ParseTuple(args, "Os", &py_ldb, &ldap_display_name)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); schema = dsdb_get_schema(ldb, NULL); if (!schema) { PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb"); return NULL; } attribute = dsdb_attribute_by_lDAPDisplayName(schema, ldap_display_name); if (attribute == NULL) { PyErr_Format(PyExc_KeyError, "Failed to find attribute '%s'", ldap_display_name); return NULL; } return PyInt_FromLong(attribute->linkID); }
static PyObject *py_samdb_server_site_name(PyObject *self, PyObject *args) { PyObject *py_ldb, *result; struct ldb_context *ldb; const char *site; TALLOC_CTX *mem_ctx; if (!PyArg_ParseTuple(args, "O", &py_ldb)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); mem_ctx = talloc_new(NULL); if (mem_ctx == NULL) { PyErr_NoMemory(); return NULL; } site = samdb_server_site_name(ldb, mem_ctx); if (site == NULL) { PyErr_SetString(PyExc_RuntimeError, "Failed to find server site"); talloc_free(mem_ctx); return NULL; } result = PyString_FromString(site); talloc_free(mem_ctx); return result; }
static PyObject *py_dsdb_get_lDAPDisplayName_by_attid(PyObject *self, PyObject *args) { PyObject *py_ldb; struct ldb_context *ldb; struct dsdb_schema *schema; const struct dsdb_attribute *a; uint32_t attid; if (!PyArg_ParseTuple(args, "Oi", &py_ldb, &attid)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); schema = dsdb_get_schema(ldb, NULL); if (!schema) { PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb"); return NULL; } a = dsdb_attribute_by_attributeID_id(schema, attid); if (a == NULL) { PyErr_Format(PyExc_KeyError, "Failed to find attribute '0x%08x'", attid); return NULL; } return PyString_FromString(a->lDAPDisplayName); }
static PyObject *py_dsdb_get_wellknown_dn(PyObject *self, PyObject *args) { struct ldb_context *ldb; struct ldb_dn *nc_dn, *wk_dn; char *wkguid; PyObject *py_ldb, *py_nc_dn, *py_wk_dn; int ret; if (!PyArg_ParseTuple(args, "OOs", &py_ldb, &py_nc_dn, &wkguid)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); PyErr_LDB_DN_OR_RAISE(py_nc_dn, nc_dn); ret = dsdb_wellknown_dn(ldb, ldb, nc_dn, wkguid, &wk_dn); if (ret == LDB_ERR_NO_SUCH_OBJECT) { PyErr_Format(PyExc_KeyError, "Failed to find well known DN for GUID %s", wkguid); return NULL; } PyErr_LDB_ERROR_IS_ERR_RAISE(py_ldb_get_exception(), ret, ldb); py_wk_dn = pyldb_Dn_FromDn(wk_dn); talloc_unlink(ldb, wk_dn); return py_wk_dn; }
static PyObject *py_samdb_get_domain_sid(PyLdbObject *self, PyObject *args) { PyObject *py_ldb; struct ldb_context *ldb; const struct dom_sid *sid; PyObject *ret; char *retstr; if (!PyArg_ParseTuple(args, "O", &py_ldb)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); sid = samdb_domain_sid(ldb); if (!sid) { PyErr_SetString(PyExc_RuntimeError, "samdb_domain_sid failed"); return NULL; } retstr = dom_sid_string(NULL, sid); if (retstr == NULL) { PyErr_NoMemory(); return NULL; } ret = PyString_FromString(retstr); talloc_free(retstr); return ret; }
static PyObject *py_samdb_set_domain_sid(PyLdbObject *self, PyObject *args) { PyObject *py_ldb, *py_sid; struct ldb_context *ldb; struct dom_sid *sid; bool ret; if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_sid)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); sid = dom_sid_parse_talloc(NULL, PyString_AsString(py_sid)); if (sid == NULL) { PyErr_NoMemory(); return NULL; } ret = samdb_set_domain_sid(ldb, sid); talloc_free(sid); if (!ret) { PyErr_SetString(PyExc_RuntimeError, "set_domain_sid failed"); return NULL; } Py_RETURN_NONE; }
static PyObject *py_dsdb_set_opaque_integer(PyObject *self, PyObject *args) { PyObject *py_ldb; int value; int *old_val, *new_val; char *py_opaque_name, *opaque_name_talloc; struct ldb_context *ldb; TALLOC_CTX *tmp_ctx; if (!PyArg_ParseTuple(args, "Osi", &py_ldb, &py_opaque_name, &value)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); /* see if we have a cached copy */ old_val = (int *)ldb_get_opaque(ldb, py_opaque_name); if (old_val) { *old_val = value; Py_RETURN_NONE; } tmp_ctx = talloc_new(ldb); if (tmp_ctx == NULL) { goto failed; } new_val = talloc(tmp_ctx, int); if (!new_val) { goto failed; } opaque_name_talloc = talloc_strdup(tmp_ctx, py_opaque_name); if (!opaque_name_talloc) { goto failed; } *new_val = value; /* cache the domain_sid in the ldb */ if (ldb_set_opaque(ldb, opaque_name_talloc, new_val) != LDB_SUCCESS) { goto failed; } talloc_steal(ldb, new_val); talloc_steal(ldb, opaque_name_talloc); talloc_free(tmp_ctx); Py_RETURN_NONE; failed: talloc_free(tmp_ctx); PyErr_SetString(PyExc_RuntimeError, "Failed to set opaque integer into the ldb!\n"); return NULL; }
static PyObject *py_ldb_set_utf8_casefold(PyObject *self, PyObject *args) { PyObject *py_ldb; struct ldb_context *ldb; if (!PyArg_ParseTuple(args, "O", &py_ldb)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); ldb_set_utf8_fns(ldb, NULL, wrap_casefold); Py_RETURN_NONE; }
/* call into samdb_is_pdc() */ static PyObject *py_dsdb_am_pdc(PyObject *self, PyObject *args) { PyObject *py_ldb; struct ldb_context *ldb; bool am_pdc; if (!PyArg_ParseTuple(args, "O", &py_ldb)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); am_pdc = samdb_is_pdc(ldb); return PyBool_FromLong(am_pdc); }
static PyObject *py_dsdb_make_schema_global(PyObject *self, PyObject *args) { PyObject *py_ldb; struct ldb_context *ldb; if (!PyArg_ParseTuple(args, "O", &py_ldb)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); dsdb_make_schema_global(ldb); Py_RETURN_NONE; }
static PyObject *py_ldb_register_samba_handlers(PyObject *self, PyObject *args) { PyObject *py_ldb; struct ldb_context *ldb; int ret; if (!PyArg_ParseTuple(args, "O", &py_ldb)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); ret = ldb_register_samba_handlers(ldb); PyErr_LDB_ERROR_IS_ERR_RAISE(py_ldb_get_exception(), ret, ldb); Py_RETURN_NONE; }
static PyObject *py_dsdb_set_global_schema(PyObject *self, PyObject *args) { PyObject *py_ldb; struct ldb_context *ldb; int ret; if (!PyArg_ParseTuple(args, "O", &py_ldb)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); ret = dsdb_set_global_schema(ldb); PyErr_LDB_ERROR_IS_ERR_RAISE(py_ldb_get_exception(), ret, ldb); Py_RETURN_NONE; }
static PyObject *py_dsdb_set_schema_from_ldif(PyObject *self, PyObject *args) { WERROR result; char *pf, *df, *dn; PyObject *py_ldb; struct ldb_context *ldb; if (!PyArg_ParseTuple(args, "Osss", &py_ldb, &pf, &df, &dn)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); result = dsdb_set_schema_from_ldif(ldb, pf, df, dn); PyErr_WERROR_NOT_OK_RAISE(result); Py_RETURN_NONE; }
static PyObject *py_dsdb_load_partition_usn(PyObject *self, PyObject *args) { PyObject *py_dn, *py_ldb, *result; struct ldb_dn *dn; uint64_t highest_uSN, urgent_uSN; struct ldb_context *ldb; TALLOC_CTX *mem_ctx; int ret; if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_dn)) { return NULL; } PyErr_LDB_OR_RAISE(py_ldb, ldb); mem_ctx = talloc_new(NULL); if (mem_ctx == NULL) { PyErr_NoMemory(); return NULL; } if (!pyldb_Object_AsDn(mem_ctx, py_dn, ldb, &dn)) { talloc_free(mem_ctx); return NULL; } ret = dsdb_load_partition_usn(ldb, dn, &highest_uSN, &urgent_uSN); if (ret != LDB_SUCCESS) { PyErr_Format(PyExc_RuntimeError, "Failed to load partition [%s] uSN - %s", ldb_dn_get_linearized(dn), ldb_errstring(ldb)); talloc_free(mem_ctx); return NULL; } talloc_free(mem_ctx); result = PyDict_New(); PyDict_SetItemString(result, "uSNHighest", PyInt_FromLong((uint64_t)highest_uSN)); PyDict_SetItemString(result, "uSNUrgent", PyInt_FromLong((uint64_t)urgent_uSN)); return result; }
static PyObject *py_dsdb_set_am_rodc(PyObject *self, PyObject *args) { PyObject *py_ldb; bool ret; struct ldb_context *ldb; int py_val; if (!PyArg_ParseTuple(args, "Oi", &py_ldb, &py_val)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); ret = samdb_set_am_rodc(ldb, (bool)py_val); if (!ret) { PyErr_SetString(PyExc_RuntimeError, "set_am_rodc failed"); return NULL; } Py_RETURN_NONE; }
static PyObject *py_dsdb_set_ntds_invocation_id(PyObject *self, PyObject *args) { PyObject *py_ldb, *py_guid; bool ret; struct GUID guid; struct ldb_context *ldb; if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_guid)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); GUID_from_string(PyString_AsString(py_guid), &guid); ret = samdb_set_ntds_invocation_id(ldb, &guid); if (!ret) { PyErr_SetString(PyExc_RuntimeError, "set_ntds_invocation_id failed"); return NULL; } Py_RETURN_NONE; }
static PyObject *py_dsdb_get_oid_from_attid(PyObject *self, PyObject *args) { PyObject *py_ldb; struct ldb_context *ldb; uint32_t attid; struct dsdb_schema *schema; const char *oid; PyObject *ret; WERROR status; TALLOC_CTX *mem_ctx; if (!PyArg_ParseTuple(args, "Oi", &py_ldb, &attid)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); mem_ctx = talloc_new(NULL); if (!mem_ctx) { PyErr_NoMemory(); return NULL; } schema = dsdb_get_schema(ldb, mem_ctx); if (!schema) { PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb \n"); talloc_free(mem_ctx); return NULL; } status = dsdb_schema_pfm_oid_from_attid(schema->prefixmap, attid, mem_ctx, &oid); if (!W_ERROR_IS_OK(status)) { PyErr_SetWERROR(status); talloc_free(mem_ctx); return NULL; } ret = PyString_FromString(oid); talloc_free(mem_ctx); return ret; }
static PyObject *py_dsdb_get_attid_from_lDAPDisplayName(PyObject *self, PyObject *args) { PyObject *py_ldb, *is_schema_nc; struct ldb_context *ldb; struct dsdb_schema *schema; const char *ldap_display_name; bool schema_nc = false; const struct dsdb_attribute *a; uint32_t attid; if (!PyArg_ParseTuple(args, "OsO", &py_ldb, &ldap_display_name, &is_schema_nc)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); if (is_schema_nc) { if (!PyBool_Check(is_schema_nc)) { PyErr_SetString(PyExc_TypeError, "Expected boolean is_schema_nc"); return NULL; } if (is_schema_nc == Py_True) { schema_nc = true; } } schema = dsdb_get_schema(ldb, NULL); if (!schema) { PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb"); return NULL; } a = dsdb_attribute_by_lDAPDisplayName(schema, ldap_display_name); if (a == NULL) { PyErr_Format(PyExc_KeyError, "Failed to find attribute '%s'", ldap_display_name); return NULL; } attid = dsdb_attribute_get_attid(a, schema_nc); return PyLong_FromUnsignedLong(attid); }
static PyObject *py_ldb_set_loadparm(PyObject *self, PyObject *args) { PyObject *py_lp_ctx, *py_ldb; struct loadparm_context *lp_ctx; struct ldb_context *ldb; if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_lp_ctx)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); lp_ctx = lp_from_py_object(py_lp_ctx); if (lp_ctx == NULL) { PyErr_SetString(PyExc_TypeError, "Expected loadparm object"); return NULL; } ldb_set_opaque(ldb, "loadparm", lp_ctx); Py_RETURN_NONE; }
static PyObject *py_ldb_set_credentials(PyObject *self, PyObject *args) { PyObject *py_creds, *py_ldb; struct cli_credentials *creds; struct ldb_context *ldb; if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_creds)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); creds = cli_credentials_from_py_object(py_creds); if (creds == NULL) { PyErr_SetString(PyExc_TypeError, "Expected credentials object"); return NULL; } ldb_set_opaque(ldb, "credentials", creds); Py_RETURN_NONE; }
/* call into samdb_rodc() */ static PyObject *py_dsdb_am_rodc(PyObject *self, PyObject *args) { PyObject *py_ldb; struct ldb_context *ldb; int ret; bool am_rodc; if (!PyArg_ParseTuple(args, "O", &py_ldb)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); ret = samdb_rodc(ldb, &am_rodc); if (ret != LDB_SUCCESS) { PyErr_SetString(PyExc_RuntimeError, ldb_errstring(ldb)); return NULL; } return PyBool_FromLong(am_rodc); }
static PyObject *py_ldb_set_session_info(PyObject *self, PyObject *args) { PyObject *py_session_info, *py_ldb; struct auth_session_info *info; struct ldb_context *ldb; if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_session_info)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); /*if (!PyAuthSession_Check(py_session_info)) { PyErr_SetString(PyExc_TypeError, "Expected session info object"); return NULL; }*/ info = PyAuthSession_AsSession(py_session_info); ldb_set_opaque(ldb, "sessionInfo", info); Py_RETURN_NONE; }
static PyObject *py_dsdb_get_nc_root(PyObject *self, PyObject *args) { struct ldb_context *ldb; struct ldb_dn *dn, *nc_root; PyObject *py_ldb, *py_ldb_dn, *py_nc_root; int ret; if (!PyArg_ParseTuple(args, "OO", &py_ldb, &py_ldb_dn)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); PyErr_LDB_DN_OR_RAISE(py_ldb_dn, dn); ret = dsdb_find_nc_root(ldb, ldb, dn, &nc_root); PyErr_LDB_ERROR_IS_ERR_RAISE(py_ldb_get_exception(), ret, ldb); py_nc_root = pyldb_Dn_FromDn(nc_root); talloc_unlink(ldb, nc_root); return py_nc_root; }
static PyObject *py_dsdb_get_partitions_dn(PyObject *self, PyObject *args) { struct ldb_context *ldb; struct ldb_dn *dn; PyObject *py_ldb, *ret; if (!PyArg_ParseTuple(args, "O", &py_ldb)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); dn = samdb_partitions_dn(ldb, NULL); if (dn == NULL) { PyErr_NoMemory(); return NULL; } ret = pyldb_Dn_FromDn(dn); talloc_free(dn); return ret; }
/* return the backlink attribute name (if any) for an attribute */ static PyObject *py_dsdb_get_backlink_from_lDAPDisplayName(PyObject *self, PyObject *args) { PyObject *py_ldb; struct ldb_context *ldb; struct dsdb_schema *schema; const char *ldap_display_name; const struct dsdb_attribute *attribute, *target_attr; if (!PyArg_ParseTuple(args, "Os", &py_ldb, &ldap_display_name)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); schema = dsdb_get_schema(ldb, NULL); if (!schema) { PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb"); return NULL; } attribute = dsdb_attribute_by_lDAPDisplayName(schema, ldap_display_name); if (attribute == NULL) { PyErr_Format(PyExc_KeyError, "Failed to find attribute '%s'", ldap_display_name); return NULL; } if (attribute->linkID == 0) { Py_RETURN_NONE; } target_attr = dsdb_attribute_by_linkID(schema, attribute->linkID ^ 1); if (target_attr == NULL) { /* when we add pseudo-backlinks we'll need to handle them here */ Py_RETURN_NONE; } return PyString_FromString(target_attr->lDAPDisplayName); }
static PyObject *py_dsdb_write_prefixes_from_schema_to_ldb(PyObject *self, PyObject *args) { PyObject *py_ldb; struct ldb_context *ldb; WERROR result; struct dsdb_schema *schema; if (!PyArg_ParseTuple(args, "O", &py_ldb)) return NULL; PyErr_LDB_OR_RAISE(py_ldb, ldb); schema = dsdb_get_schema(ldb, NULL); if (!schema) { PyErr_SetString(PyExc_RuntimeError, "Failed to set find a schema on ldb!\n"); return NULL; } result = dsdb_write_prefixes_from_schema_to_ldb(NULL, ldb, schema); PyErr_WERROR_NOT_OK_RAISE(result); Py_RETURN_NONE; }
/* normalise a ldb attribute list */ static PyObject *py_dsdb_normalise_attributes(PyObject *self, PyObject *args) { PyObject *py_ldb, *el_list, *ret; struct ldb_context *ldb; char *ldap_display_name; const struct dsdb_attribute *a; struct dsdb_schema *schema; struct dsdb_syntax_ctx syntax_ctx; struct ldb_message_element *el; struct drsuapi_DsReplicaAttribute *attr; TALLOC_CTX *tmp_ctx; WERROR werr; Py_ssize_t i; if (!PyArg_ParseTuple(args, "OsO", &py_ldb, &ldap_display_name, &el_list)) { return NULL; } PyErr_LDB_OR_RAISE(py_ldb, ldb); if (!PyList_Check(el_list)) { PyErr_Format(PyExc_TypeError, "ldif_elements must be a list"); return NULL; } schema = dsdb_get_schema(ldb, NULL); if (!schema) { PyErr_SetString(PyExc_RuntimeError, "Failed to find a schema from ldb"); return NULL; } a = dsdb_attribute_by_lDAPDisplayName(schema, ldap_display_name); if (a == NULL) { PyErr_Format(PyExc_KeyError, "Failed to find attribute '%s'", ldap_display_name); return NULL; } dsdb_syntax_ctx_init(&syntax_ctx, ldb, schema); syntax_ctx.is_schema_nc = false; tmp_ctx = talloc_new(ldb); if (tmp_ctx == NULL) { PyErr_NoMemory(); return NULL; } el = talloc_zero(tmp_ctx, struct ldb_message_element); if (el == NULL) { PyErr_NoMemory(); talloc_free(tmp_ctx); return NULL; } el->name = ldap_display_name; el->num_values = PyList_Size(el_list); el->values = talloc_array(el, struct ldb_val, el->num_values); if (el->values == NULL) { PyErr_NoMemory(); talloc_free(tmp_ctx); return NULL; } for (i = 0; i < el->num_values; i++) { PyObject *item = PyList_GetItem(el_list, i); if (!PyString_Check(item)) { PyErr_Format(PyExc_TypeError, "ldif_elements should be strings"); talloc_free(tmp_ctx); return NULL; } el->values[i].data = (uint8_t *)PyString_AsString(item); el->values[i].length = PyString_Size(item); } /* Normalise "objectClass" attribute if needed */ if (ldb_attr_cmp(a->lDAPDisplayName, "objectClass") == 0) { int iret; iret = dsdb_sort_objectClass_attr(ldb, schema, el, tmp_ctx, el); if (iret != LDB_SUCCESS) { PyErr_SetString(PyExc_RuntimeError, ldb_errstring(ldb)); talloc_free(tmp_ctx); return NULL; } } /* first run ldb_to_drsuapi, then convert back again. This has * the effect of normalising the attributes */ attr = talloc_zero(tmp_ctx, struct drsuapi_DsReplicaAttribute); if (attr == NULL) { PyErr_NoMemory(); talloc_free(tmp_ctx); return NULL; } werr = a->syntax->ldb_to_drsuapi(&syntax_ctx, a, el, attr, attr); PyErr_WERROR_NOT_OK_RAISE(werr); /* now convert back again */ werr = a->syntax->drsuapi_to_ldb(&syntax_ctx, a, attr, el, el); PyErr_WERROR_NOT_OK_RAISE(werr); ret = py_return_ndr_struct("ldb", "MessageElement", el, el); talloc_free(tmp_ctx); return ret; }