s3-passdb: Added python wrapper for passdb methods

Added following methods
 - uid_to_sid, gid_to_sid, sid_to_id, new_rid
 - get_trusteddom_pw, set_trusteddom_pw, del_trusteddom_pw, enum_trusteddoms
 - get_trusted_domain, get_trusted_domain_by_sid, set_trusted_domain,
   del_trusted_domain, enum_trusted_domains
 - get_secret, set_secret, delete_secret

Updated documentation for all methods

Signed-off-by: Andrew Bartlett <abartlet@samba.org>

1 files changed, 831 insertions, 21 deletions

diff --git a/source3/passdb/py_passdb.c b/source3/passdb/py_passdb.c
index 2b3ac52110..5b10c465fe 100644
--- a/source3/passdb/py_passdb.c
+++ b/source3/passdb/py_passdb.c
@@ -43,6 +43,7 @@
 
 
 static PyTypeObject *dom_sid_Type = NULL;
+static PyTypeObject *security_Type = NULL;
 static PyTypeObject *guid_Type = NULL;
 
 staticforward PyTypeObject PySamu;
@@ -2544,6 +2545,777 @@ static PyObject *py_pdb_search_aliases(pytalloc_Object *self, PyObject *args)
 	return py_aliaslist;
 }
 
+
+static PyObject *py_pdb_uid_to_sid(pytalloc_Object *self, PyObject *args)
+{
+	struct pdb_methods *methods;
+	TALLOC_CTX *tframe;
+	unsigned int uid;
+	struct dom_sid user_sid, *copy_user_sid;
+	PyObject *py_user_sid;
+
+	if (!PyArg_ParseTuple(args, "I:uid_to_sid", &uid)) {
+		return NULL;
+	}
+
+	methods = pytalloc_get_ptr(self);
+
+	if ((tframe = talloc_stackframe()) == NULL) {
+		PyErr_NoMemory();
+		return NULL;
+	}
+
+	if (!methods->uid_to_sid(methods, uid, &user_sid)) {
+		PyErr_Format(py_pdb_error, "Unable to get sid for uid=%d", uid);
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	copy_user_sid = dom_sid_dup(tframe, &user_sid);
+	if (copy_user_sid == NULL) {
+		PyErr_NoMemory();
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	py_user_sid = pytalloc_steal(dom_sid_Type, copy_user_sid);
+
+	talloc_free(tframe);
+
+	return py_user_sid;
+}
+
+
+static PyObject *py_pdb_gid_to_sid(pytalloc_Object *self, PyObject *args)
+{
+	struct pdb_methods *methods;
+	TALLOC_CTX *tframe;
+	unsigned int gid;
+	struct dom_sid group_sid, *copy_group_sid;
+	PyObject *py_group_sid;
+
+	if (!PyArg_ParseTuple(args, "I:gid_to_sid", &gid)) {
+		return NULL;
+	}
+
+	methods = pytalloc_get_ptr(self);
+
+	if ((tframe = talloc_stackframe()) == NULL) {
+		PyErr_NoMemory();
+		return NULL;
+	}
+
+	if (!methods->gid_to_sid(methods, gid, &group_sid)) {
+		PyErr_Format(py_pdb_error, "Unable to get sid for gid=%d", gid);
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	copy_group_sid = dom_sid_dup(tframe, &group_sid);
+	if (copy_group_sid == NULL) {
+		PyErr_NoMemory();
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	py_group_sid = pytalloc_steal(dom_sid_Type, copy_group_sid);
+
+	talloc_free(tframe);
+
+	return py_group_sid;
+}
+
+
+static PyObject *py_pdb_sid_to_id(pytalloc_Object *self, PyObject *args)
+{
+	struct pdb_methods *methods;
+	TALLOC_CTX *tframe;
+	PyObject *py_sid;
+	struct dom_sid *sid;
+	union unid_t id;
+	enum lsa_SidType type;
+
+	if (!PyArg_ParseTuple(args, "O!:sid_to_id", dom_sid_Type, &py_sid)) {
+		return NULL;
+	}
+
+	methods = pytalloc_get_ptr(self);
+
+	if ((tframe = talloc_stackframe()) == NULL) {
+		PyErr_NoMemory();
+		return NULL;
+	}
+
+	sid = pytalloc_get_ptr(py_sid);
+
+	if (!methods->sid_to_id(methods, sid, &id, &type)) {
+		PyErr_Format(py_pdb_error, "Unable to get id for sid");
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	talloc_free(tframe);
+
+	return Py_BuildValue("(II)", id.uid, type);
+}
+
+
+static PyObject *py_pdb_new_rid(pytalloc_Object *self)
+{
+	struct pdb_methods *methods;
+	TALLOC_CTX *tframe;
+	uint32_t rid;
+
+	methods = pytalloc_get_ptr(self);
+
+	if ((tframe = talloc_stackframe()) == NULL) {
+		PyErr_NoMemory();
+		return NULL;
+	}
+
+	if (!methods->new_rid(methods, &rid)) {
+		PyErr_Format(py_pdb_error, "Unable to get new rid");
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	talloc_free(tframe);
+
+	return PyInt_FromLong(rid);
+}
+
+
+static PyObject *py_pdb_get_trusteddom_pw(pytalloc_Object *self, PyObject *args)
+{
+	struct pdb_methods *methods;
+	TALLOC_CTX *tframe;
+	const char *domain;
+	char *pwd;
+	struct dom_sid sid, *copy_sid;
+	PyObject *py_sid;
+	time_t last_set_time;
+	PyObject *py_value;
+
+	if (!PyArg_ParseTuple(args, "s:get_trusteddom_pw", &domain)) {
+		return NULL;
+	}
+
+	methods = pytalloc_get_ptr(self);
+
+	if ((tframe = talloc_stackframe()) == NULL) {
+		PyErr_NoMemory();
+		return NULL;
+	}
+
+	if (!methods->get_trusteddom_pw(methods, domain, &pwd, &sid, &last_set_time)) {
+		PyErr_Format(py_pdb_error, "Unable to get trusted domain password");
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	copy_sid = dom_sid_dup(tframe, &sid);
+	if (copy_sid == NULL) {
+		PyErr_NoMemory();
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	py_sid = pytalloc_steal(dom_sid_Type, copy_sid);
+	if (py_sid == NULL) {
+		PyErr_NoMemory();
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	talloc_free(tframe);
+
+	py_value = PyDict_New();
+	if (py_value == NULL) {
+		PyErr_NoMemory();
+		return NULL;
+	}
+
+	PyDict_SetItemString(py_value, "pwd", PyString_FromString(pwd));
+	PyDict_SetItemString(py_value, "sid", py_sid);
+	PyDict_SetItemString(py_value, "last_set_tim", PyInt_FromLong(last_set_time));
+
+	return py_value;
+}
+
+
+static PyObject *py_pdb_set_trusteddom_pw(pytalloc_Object *self, PyObject *args)
+{
+	struct pdb_methods *methods;
+	TALLOC_CTX *tframe;
+	const char *domain;
+	const char *pwd;
+	const struct dom_sid *domain_sid;
+	PyObject *py_domain_sid;
+
+	if (!PyArg_ParseTuple(args, "ssO!:set_trusteddom_pw", &domain, &pwd,
+					dom_sid_Type, &py_domain_sid)) {
+		return NULL;
+	}
+
+	methods = pytalloc_get_ptr(self);
+
+	if ((tframe = talloc_stackframe()) == NULL) {
+		PyErr_NoMemory();
+		return NULL;
+	}
+
+	domain_sid = pytalloc_get_ptr(py_domain_sid);
+
+	if (!methods->set_trusteddom_pw(methods, domain, pwd, domain_sid)) {
+		PyErr_Format(py_pdb_error, "Unable to set trusted domain password");
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	Py_RETURN_NONE;
+}
+
+
+static PyObject *py_pdb_del_trusteddom_pw(pytalloc_Object *self, PyObject *args)
+{
+	struct pdb_methods *methods;
+	TALLOC_CTX *tframe;
+	const char *domain;
+
+	if (!PyArg_ParseTuple(args, "s:del_trusteddom_pw", &domain)) {
+		return NULL;
+	}
+
+	methods = pytalloc_get_ptr(self);
+
+	if ((tframe = talloc_stackframe()) == NULL) {
+		PyErr_NoMemory();
+		return NULL;
+	}
+
+	if (!methods->del_trusteddom_pw(methods, domain)) {
+		PyErr_Format(py_pdb_error, "Unable to delete trusted domain password");
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	Py_RETURN_NONE;
+}
+
+
+static PyObject *py_pdb_enum_trusteddoms(pytalloc_Object *self)
+{
+	NTSTATUS status;
+	struct pdb_methods *methods;
+	TALLOC_CTX *tframe;
+	uint32_t num_domains;
+	struct trustdom_info **domains;
+	PyObject *py_domain_list, *py_dict;
+	int i;
+
+	methods = pytalloc_get_ptr(self);
+
+	if ((tframe = talloc_stackframe()) == NULL) {
+		PyErr_NoMemory();
+		return NULL;
+	}
+
+	status = methods->enum_trusteddoms(methods, tframe, &num_domains, &domains);
+	if (!NT_STATUS_IS_OK(status)) {
+		PyErr_Format(py_pdb_error, "Unable to enumerate trusted domains, (%d,%s)",
+				NT_STATUS_V(status),
+				get_friendly_nt_error_msg(status));
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	py_domain_list = PyList_New(0);
+	if (py_domain_list == NULL) {
+		PyErr_NoMemory();
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	for(i=0; i<num_domains; i++) {
+		py_dict = PyDict_New();
+		if (py_dict) {
+			PyDict_SetItemString(py_dict, "name",
+					PyString_FromString(domains[i]->name));
+			PyDict_SetItemString(py_dict, "sid",
+					pytalloc_steal(dom_sid_Type, &domains[i]->sid));
+		}
+
+		PyList_Append(py_domain_list, py_dict);
+	}
+
+	talloc_free(tframe);
+
+	return py_domain_list;
+}
+
+
+static PyObject *py_pdb_get_trusted_domain(pytalloc_Object *self, PyObject *args)
+{
+	NTSTATUS status;
+	struct pdb_methods *methods;
+	TALLOC_CTX *tframe;
+	const char *domain;
+	struct pdb_trusted_domain *td;
+	PyObject *py_domain_info;
+
+	if (!PyArg_ParseTuple(args, "s:get_trusted_domain", &domain)) {
+		return NULL;
+	}
+
+	methods = pytalloc_get_ptr(self);
+
+	if ((tframe = talloc_stackframe()) == NULL) {
+		PyErr_NoMemory();
+		return NULL;
+	}
+
+	status = methods->get_trusted_domain(methods, tframe, domain, &td);
+	if (!NT_STATUS_IS_OK(status)) {
+		PyErr_Format(py_pdb_error, "Unable to get trusted domain information, (%d,%s)",
+				NT_STATUS_V(status),
+				get_friendly_nt_error_msg(status));
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	py_domain_info = PyDict_New();
+	if (py_domain_info == NULL) {
+		PyErr_NoMemory();
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	PyDict_SetItemString(py_domain_info, "domain_name",
+			PyString_FromString(td->domain_name));
+	PyDict_SetItemString(py_domain_info, "netbios_name",
+			PyString_FromString(td->netbios_name));
+	PyDict_SetItemString(py_domain_info, "security_identifier",
+			pytalloc_steal(dom_sid_Type, &td->security_identifier));
+	PyDict_SetItemString(py_domain_info, "trust_auth_incoming",
+			PyString_FromStringAndSize((char *)td->trust_auth_incoming.data,
+						td->trust_auth_incoming.length));
+	PyDict_SetItemString(py_domain_info, "trust_auth_outgoing",
+			PyString_FromStringAndSize((char *)td->trust_auth_outgoing.data,
+						td->trust_auth_outgoing.length));
+	PyDict_SetItemString(py_domain_info, "trust_direction",
+			PyInt_FromLong(td->trust_direction));
+	PyDict_SetItemString(py_domain_info, "trust_type",
+			PyInt_FromLong(td->trust_type));
+	PyDict_SetItemString(py_domain_info, "trust_attributes",
+			PyInt_FromLong(td->trust_attributes));
+	PyDict_SetItemString(py_domain_info, "trust_forest_trust_info",
+			PyString_FromStringAndSize((char *)td->trust_forest_trust_info.data,
+						td->trust_forest_trust_info.length));
+
+	talloc_free(tframe);
+
+	return py_domain_info;
+}
+
+
+static PyObject *py_pdb_get_trusted_domain_by_sid(pytalloc_Object *self, PyObject *args)
+{
+	NTSTATUS status;
+	struct pdb_methods *methods;
+	TALLOC_CTX *tframe;
+	PyObject *py_domain_sid;
+	struct dom_sid *domain_sid;
+	struct pdb_trusted_domain *td;
+	PyObject *py_domain_info;
+
+	if (!PyArg_ParseTuple(args, "O!:get_trusted_domain_by_sid", dom_sid_Type, &py_domain_sid)) {
+		return NULL;
+	}
+
+	methods = pytalloc_get_ptr(self);
+
+	if ((tframe = talloc_stackframe()) == NULL) {
+		PyErr_NoMemory();
+		return NULL;
+	}
+
+	domain_sid = pytalloc_get_ptr(py_domain_sid);
+
+	status = methods->get_trusted_domain_by_sid(methods, tframe, domain_sid, &td);
+	if (!NT_STATUS_IS_OK(status)) {
+		PyErr_Format(py_pdb_error, "Unable to get trusted domain information, (%d,%s)",
+				NT_STATUS_V(status),
+				get_friendly_nt_error_msg(status));
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	py_domain_info = PyDict_New();
+	if (py_domain_info == NULL) {
+		PyErr_NoMemory();
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	PyDict_SetItemString(py_domain_info, "domain_name",
+			PyString_FromString(td->domain_name));
+	PyDict_SetItemString(py_domain_info, "netbios_name",
+			PyString_FromString(td->netbios_name));
+	PyDict_SetItemString(py_domain_info, "security_identifier",
+			pytalloc_steal(dom_sid_Type, &td->security_identifier));
+	PyDict_SetItemString(py_domain_info, "trust_auth_incoming",
+			PyString_FromStringAndSize((char *)td->trust_auth_incoming.data,
+						td->trust_auth_incoming.length));
+	PyDict_SetItemString(py_domain_info, "trust_auth_outgoing",
+			PyString_FromStringAndSize((char *)td->trust_auth_outgoing.data,
+						td->trust_auth_outgoing.length));
+	PyDict_SetItemString(py_domain_info, "trust_direction",
+			PyInt_FromLong(td->trust_direction));
+	PyDict_SetItemString(py_domain_info, "trust_type",
+			PyInt_FromLong(td->trust_type));
+	PyDict_SetItemString(py_domain_info, "trust_attributes",
+			PyInt_FromLong(td->trust_attributes));
+	PyDict_SetItemString(py_domain_info, "trust_forest_trust_info",
+			PyString_FromStringAndSize((char *)td->trust_forest_trust_info.data,
+						td->trust_forest_trust_info.length));
+
+	talloc_free(tframe);
+
+	return py_domain_info;
+}
+
+
+static PyObject *py_pdb_set_trusted_domain(pytalloc_Object *self, PyObject *args)
+{
+	NTSTATUS status;
+	struct pdb_methods *methods;
+	TALLOC_CTX *tframe;
+	const char *domain;
+	PyObject *py_td_info;
+	struct pdb_trusted_domain td_info;
+	PyObject *py_tmp;
+	Py_ssize_t len;
+
+	if (!PyArg_ParseTuple(args, "sO!:set_trusted_domain", &domain, &PyDict_Type, &py_td_info)) {
+		return NULL;
+	}
+
+	py_tmp = PyDict_GetItemString(py_td_info, "domain_name");
+	td_info.domain_name = PyString_AsString(py_tmp);
+
+	py_tmp = PyDict_GetItemString(py_td_info, "netbios_name");
+	td_info.netbios_name = PyString_AsString(py_tmp);
+
+	py_tmp = PyDict_GetItemString(py_td_info, "security_identifier");
+	td_info.security_identifier = *pytalloc_get_type(py_tmp, struct dom_sid);
+
+	py_tmp = PyDict_GetItemString(py_td_info, "trust_auth_incoming");
+	PyString_AsStringAndSize(py_tmp, (char **)&td_info.trust_auth_incoming.data, &len);
+	td_info.trust_auth_incoming.length = len;
+
+	py_tmp = PyDict_GetItemString(py_td_info, "trust_auth_outgoing");
+	PyString_AsStringAndSize(py_tmp, (char **)&td_info.trust_auth_outgoing.data, &len);
+	td_info.trust_auth_outgoing.length = len;
+
+	py_tmp = PyDict_GetItemString(py_td_info, "trust_direction");
+	td_info.trust_direction = PyInt_AsLong(py_tmp);
+
+	py_tmp = PyDict_GetItemString(py_td_info, "trust_type");
+	td_info.trust_type = PyInt_AsLong(py_tmp);
+
+	py_tmp = PyDict_GetItemString(py_td_info, "trust_attributes");
+	td_info.trust_attributes = PyInt_AsLong(py_tmp);
+
+	py_tmp = PyDict_GetItemString(py_td_info, "trust_forest_trust_info");
+	PyString_AsStringAndSize(py_tmp, (char **)&td_info.trust_forest_trust_info.data, &len);
+	td_info.trust_forest_trust_info.length = len;
+
+	methods = pytalloc_get_ptr(self);
+
+	if ((tframe = talloc_stackframe()) == NULL) {
+		PyErr_NoMemory();
+		return NULL;
+	}
+
+	status = methods->set_trusted_domain(methods, domain, &td_info);
+	if (!NT_STATUS_IS_OK(status)) {
+		PyErr_Format(py_pdb_error, "Unable to set trusted domain information, (%d,%s)",
+				NT_STATUS_V(status),
+				get_friendly_nt_error_msg(status));
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	talloc_free(tframe);
+
+	Py_RETURN_NONE;
+}
+
+
+static PyObject *py_pdb_del_trusted_domain(pytalloc_Object *self, PyObject *args)
+{
+	NTSTATUS status;
+	struct pdb_methods *methods;
+	TALLOC_CTX *tframe;
+	const char *domain;
+
+	if (!PyArg_ParseTuple(args, "s:del_trusted_domain", &domain)) {
+		return NULL;
+	}
+
+	methods = pytalloc_get_ptr(self);
+
+	if ((tframe = talloc_stackframe()) == NULL) {
+		PyErr_NoMemory();
+		return NULL;
+	}
+
+	status = methods->del_trusted_domain(methods, domain);
+	if (!NT_STATUS_IS_OK(status)) {
+		PyErr_Format(py_pdb_error, "Unable to delete trusted domain, (%d,%s)",
+				NT_STATUS_V(status),
+				get_friendly_nt_error_msg(status));
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	talloc_free(tframe);
+
+	Py_RETURN_NONE;
+}
+
+
+static PyObject *py_pdb_enum_trusted_domains(pytalloc_Object *self)
+{
+	NTSTATUS status;
+	struct pdb_methods *methods;
+	TALLOC_CTX *tframe;
+	uint32_t num_domains;
+	struct pdb_trusted_domain **td_info, *td;
+	PyObject *py_td_info, *py_domain_info;
+	int i;
+
+	methods = pytalloc_get_ptr(self);
+
+	if ((tframe = talloc_stackframe()) == NULL) {
+		PyErr_NoMemory();
+		return NULL;
+	}
+
+	status = methods->enum_trusted_domains(methods, tframe, &num_domains, &td_info);
+	if (!NT_STATUS_IS_OK(status)) {
+		PyErr_Format(py_pdb_error, "Unable to delete trusted domain, (%d,%s)",
+				NT_STATUS_V(status),
+				get_friendly_nt_error_msg(status));
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	py_td_info = PyList_New(0);
+	if (py_td_info == NULL) {
+		PyErr_NoMemory();
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	for (i=0; i<num_domains; i++) {
+
+		py_domain_info = PyDict_New();
+		if (py_domain_info == NULL) {
+			PyErr_NoMemory();
+			Py_DECREF(py_td_info);
+			talloc_free(tframe);
+			return NULL;
+		}
+
+		td = td_info[i];
+
+		PyDict_SetItemString(py_domain_info, "domain_name",
+				PyString_FromString(td->domain_name));
+		PyDict_SetItemString(py_domain_info, "netbios_name",
+				PyString_FromString(td->netbios_name));
+		PyDict_SetItemString(py_domain_info, "security_identifier",
+				pytalloc_steal(dom_sid_Type, &td->security_identifier));
+		PyDict_SetItemString(py_domain_info, "trust_auth_incoming",
+				PyString_FromStringAndSize((char *)td->trust_auth_incoming.data,
+							td->trust_auth_incoming.length));
+		PyDict_SetItemString(py_domain_info, "trust_auth_outgoing",
+				PyString_FromStringAndSize((char *)td->trust_auth_outgoing.data,
+							td->trust_auth_outgoing.length));
+		PyDict_SetItemString(py_domain_info, "trust_direction",
+				PyInt_FromLong(td->trust_direction));
+		PyDict_SetItemString(py_domain_info, "trust_type",
+				PyInt_FromLong(td->trust_type));
+		PyDict_SetItemString(py_domain_info, "trust_attributes",
+				PyInt_FromLong(td->trust_attributes));
+		PyDict_SetItemString(py_domain_info, "trust_forest_trust_info",
+				PyString_FromStringAndSize((char *)td->trust_forest_trust_info.data,
+							td->trust_forest_trust_info.length));
+		PyList_Append(py_td_info, py_domain_info);
+	}
+
+	talloc_free(tframe);
+
+	return py_td_info;
+}
+
+
+static PyObject *py_pdb_get_secret(pytalloc_Object *self, PyObject *args)
+{
+	NTSTATUS status;
+	struct pdb_methods *methods;
+	TALLOC_CTX *tframe;
+	const char *secret_name;
+	DATA_BLOB secret_current, secret_old;
+	NTTIME secret_current_lastchange, secret_old_lastchange;
+	PyObject *py_sd;
+	struct security_descriptor *sd;
+	PyObject *py_secret;
+
+	if (!PyArg_ParseTuple(args, "s:get_secret_name", &secret_name)) {
+		return NULL;
+	}
+
+	methods = pytalloc_get_ptr(self);
+
+	if ((tframe = talloc_stackframe()) == NULL) {
+		PyErr_NoMemory();
+		return NULL;
+	}
+
+	py_sd = pytalloc_new(struct security_descriptor, security_Type);
+	if (py_sd == NULL) {
+		PyErr_NoMemory();
+		talloc_free(tframe);
+		return NULL;
+	}
+	sd = pytalloc_get_ptr(py_sd);
+
+	status = methods->get_secret(methods, tframe, secret_name,
+					&secret_current,
+					&secret_current_lastchange,
+					&secret_old,
+					&secret_old_lastchange,
+					&sd);
+	if (!NT_STATUS_IS_OK(status)) {
+		PyErr_Format(py_pdb_error, "Unable to get information for secret (%s), (%d,%s)",
+				secret_name,
+				NT_STATUS_V(status),
+				get_friendly_nt_error_msg(status));
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	py_secret = PyDict_New();
+	if (py_secret == NULL) {
+		PyErr_NoMemory();
+		Py_DECREF(py_sd);
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	PyDict_SetItemString(py_secret, "secret_current",
+			PyString_FromStringAndSize((char *)secret_current.data, secret_current.length));
+	PyDict_SetItemString(py_secret, "secret_current_lastchange",
+			PyLong_FromUnsignedLongLong(secret_current_lastchange));
+	PyDict_SetItemString(py_secret, "secret_old",
+			PyString_FromStringAndSize((char *)secret_old.data, secret_old.length));
+	PyDict_SetItemString(py_secret, "secret_old_lastchange",
+			PyLong_FromUnsignedLongLong(secret_old_lastchange));
+	PyDict_SetItemString(py_secret, "sd", py_sd);
+
+	talloc_free(tframe);
+
+	return py_secret;
+}
+
+
+static PyObject *py_pdb_set_secret(pytalloc_Object *self, PyObject *args)
+{
+	NTSTATUS status;
+	struct pdb_methods *methods;
+	TALLOC_CTX *tframe;
+	const char *secret_name;
+	PyObject *py_secret;
+	PyObject *py_secret_cur, *py_secret_old, *py_sd;
+	DATA_BLOB secret_current, secret_old;
+	struct security_descriptor *sd;
+	Py_ssize_t len;
+
+	if (!PyArg_ParseTuple(args, "sO!:set_secret_name", &secret_name, PyDict_Type, &py_secret)) {
+		return NULL;
+	}
+
+	py_secret_cur = PyDict_GetItemString(py_secret, "secret_current");
+	py_secret_old = PyDict_GetItemString(py_secret, "secret_old");
+	py_sd = PyDict_GetItemString(py_secret, "sd");
+
+	PY_CHECK_TYPE(&PyString_Type, py_secret_cur, return NULL;);
+	PY_CHECK_TYPE(&PyString_Type, py_secret_old, return NULL;);
+	PY_CHECK_TYPE(security_Type, py_sd, return NULL;);
+
+	methods = pytalloc_get_ptr(self);
+
+	if ((tframe = talloc_stackframe()) == NULL) {
+		PyErr_NoMemory();
+		return NULL;
+	}
+
+	PyString_AsStringAndSize(py_secret_cur, (char **)&secret_current.data, &len);
+	secret_current.length = len;
+	PyString_AsStringAndSize(py_secret_old, (char **)&secret_old.data, &len);
+	secret_current.length = len;
+	sd = pytalloc_get_ptr(py_sd);
+
+	status = methods->set_secret(methods, secret_name, &secret_current, &secret_old, sd);
+	if (!NT_STATUS_IS_OK(status)) {
+		PyErr_Format(py_pdb_error, "Unable to set information for secret (%s), (%d,%s)",
+				secret_name,
+				NT_STATUS_V(status),
+				get_friendly_nt_error_msg(status));
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	talloc_free(tframe);
+
+	Py_RETURN_NONE;
+}
+
+
+static PyObject *py_pdb_delete_secret(pytalloc_Object *self, PyObject *args)
+{
+	NTSTATUS status;
+	struct pdb_methods *methods;
+	TALLOC_CTX *tframe;
+	const char *secret_name;
+
+	if (!PyArg_ParseTuple(args, "s:delete_secret", &secret_name)) {
+		return NULL;
+	}
+
+	methods = pytalloc_get_ptr(self);
+
+	if ((tframe = talloc_stackframe()) == NULL) {
+		PyErr_NoMemory();
+		return NULL;
+	}
+
+	status = methods->delete_secret(methods, secret_name);
+	if (!NT_STATUS_IS_OK(status)) {
+		PyErr_Format(py_pdb_error, "Unable to delete secret (%s), (%d,%s)",
+				secret_name,
+				NT_STATUS_V(status),
+				get_friendly_nt_error_msg(status));
+		talloc_free(tframe);
+		return NULL;
+	}
+
+	talloc_free(tframe);
+
+	Py_RETURN_NONE;
+}
+
 static PyMethodDef py_pdb_methods[] = {
 	{ "domain_info", (PyCFunction)py_pdb_domain_info, METH_NOARGS,
 		"domain_info() -> str\n\n \
@@ -2598,11 +3370,11 @@ static PyMethodDef py_pdb_methods[] = {
 		"delete_group_mapping_entry(groupmap) -> None\n\n \
 		Delete group mapping entry for groupmap object." },
 	{ "enum_group_mapping", (PyCFunction)py_pdb_enum_group_mapping, METH_VARARGS,
-		"enum_group_mapping(domain_sid) -> List\n\n \
-		Return list of group mappings as groupmap objects." },
+		"enum_group_mapping([domain_sid, [type, [unix_only]]]) -> List\n\n \
+		Return list of group mappings as groupmap objects. Optional arguments are domain_sid object, type of group, unix only flag." },
 	{ "enum_group_members", (PyCFunction)py_pdb_enum_group_members, METH_VARARGS,
 		"enum_group_members(group_sid) -> List\n\n \
-		Return list of group members." },
+		Return list of users (dom_sid object) in group." },
 	/* enum_group_memberships */
 	/* set_unix_primary_group */
 	{ "add_groupmem", (PyCFunction)py_pdb_add_groupmem, METH_VARARGS,
@@ -2631,7 +3403,7 @@ static PyMethodDef py_pdb_methods[] = {
 		Remove a user from alias entry." },
 	{ "enum_aliasmem", (PyCFunction)py_pdb_enum_aliasmem, METH_VARARGS,
 		"enum_aliasmem(alias_sid) -> List\n\n \
-		Return a list of users for alias entry." },
+		Return a list of members (dom_sid object) for alias entry." },
 	/* enum_alias_memberships */
 	/* lookup_rids */
 	/* lookup_names */
@@ -2654,23 +3426,55 @@ static PyMethodDef py_pdb_methods[] = {
 		"search_aliases(domain_sid) -> List\n\n \
 		Search aliases. domain_sid is dcerpc.security.dom_sid object.\n \
 		Each list entry is dictionary with keys - idx, rid, acct_flags, account_name, fullname, description." },
-	/* uid_to_sid */
-	/* gid_to_sid */
-	/* sid_to_id */
+	{ "uid_to_sid", (PyCFunction)py_pdb_uid_to_sid, METH_VARARGS,
+		"uid_to_sid(uid) -> sid\n\n \
+		Return sid for given user id." },
+	{ "gid_to_sid", (PyCFunction)py_pdb_gid_to_sid, METH_VARARGS,
+		"gid_to_sid(gid) -> sid\n\n \
+		Return sid for given group id." },
+	{ "sid_to_id", (PyCFunction)py_pdb_sid_to_id, METH_VARARGS,
+		"sid_to_id(sid) -> Tuple\n\n \
+		Return id and type for given sid." },
 	/* capabilities */
-	/* new_rid */
-	/* get_trusteddom_pw */
-	/* set_trusteddom_pw */
-	/* del_trusteddom_pw */
-	/* enum_trusteddoms */
-	/* get_trusted_domain */
-	/* get_trusted_domain_by_sid */
-	/* set_trusted_domain */
-	/* del_trusted_domain */
-	/* enum_trusted_domains */
-	/* get_secret */
-	/* set_secret */
-	/* delete_secret */
+	{ "new_rid", (PyCFunction)py_pdb_new_rid, METH_NOARGS,
+		"new_rid() -> rid\n\n \
+		Get a new rid." },
+	{ "get_trusteddom_pw", (PyCFunction)py_pdb_get_trusteddom_pw, METH_VARARGS,
+		"get_trusteddom_pw(domain) -> Mapping\n\n \
+		Get trusted domain password, sid and last set time in a dictionary." },
+	{ "set_trusteddom_pw", (PyCFunction)py_pdb_set_trusteddom_pw, METH_VARARGS,
+		"set_trusteddom_pw(domain, pwd, sid) -> None\n\n \
+		Set trusted domain password." },
+	{ "del_trusteddom_pw", (PyCFunction)py_pdb_del_trusteddom_pw, METH_VARARGS,
+		"del_trusteddom_pw(domain) -> None\n\n \
+		Delete trusted domain password." },
+	{ "enum_trusteddoms", (PyCFunction)py_pdb_enum_trusteddoms, METH_NOARGS,
+		"enum_trusteddoms() -> List\n\n \
+		Get list of trusted domains. Each item is a dictionary with name and sid keys" },
+	{ "get_trusted_domain", (PyCFunction)py_pdb_get_trusted_domain, METH_VARARGS,
+		"get_trusted_domain(domain) -> Mapping\n\n \
+		Get trusted domain information by name. Information is a dictionary with keys - domain_name, netbios_name, security_identifier, trust_auth_incoming, trust_auth_outgoing, trust_direction, trust_type, trust_attributes, trust_forest_trust_info." },
+	{ "get_trusted_domain_by_sid", (PyCFunction)py_pdb_get_trusted_domain_by_sid, METH_VARARGS,
+		"get_trusted_domain_by_sid(domain_sid) -> Mapping\n\n \
+		Get trusted domain information by sid. Information is a dictionary with keys - domain_name, netbios_name, security_identifier, trust_auth_incoming, trust_auth_outgoing, trust_direction, trust_type, trust_attributes, trust_forest_trust_info" },
+	{ "set_trusted_domain", (PyCFunction)py_pdb_set_trusted_domain, METH_VARARGS,
+		"set_trusted_domain(domain, Mapping) -> None\n\n \
+		Set trusted domain information for domain. Mapping is a dictionary with keys - domain_name, netbios_name, security_identifier, trust_auth_incoming, trust_auth_outgoing, trust_direction, trust_type, trust_attributes, trust_forest_trust_info." },
+	{ "del_trusted_domain", (PyCFunction)py_pdb_del_trusted_domain, METH_VARARGS,
+		"del_trusted_domain(domain) -> None\n\n \
+		Delete trusted domain." },
+	{ "enum_trusted_domains", (PyCFunction)py_pdb_enum_trusted_domains, METH_VARARGS,
+		"enum_trusted_domains() -> List\n\n \
+		Get list of trusted domains. Each entry is a dictionary with keys - domain_name, netbios_name, security_identifier, trust_auth_incoming, trust_auth_outgoing, trust_direction, trust_type, trust_attributes, trust_forest_trust_info." },
+	{ "get_secret", (PyCFunction)py_pdb_get_secret, METH_VARARGS,
+		"get_secret(secret_name) -> Mapping\n\n \
+		Get secret information for secret_name. Information is a dictionary with keys - secret_current, secret_current_lastchange, secret_old, secret_old_lastchange, sd." },
+	{ "set_secret", (PyCFunction)py_pdb_set_secret, METH_VARARGS,
+		"set_secret(secret_name, Mapping) -> None\n\n \
+		Set secret information for secret_name using dictionary with keys - secret_current, sd." },
+	{ "delete_secret", (PyCFunction)py_pdb_delete_secret, METH_VARARGS,
+		"delete_secret(secret_name) -> None\n\n \
+		Delete secret information for secret_name." },
 	{ NULL },
 };
 
@@ -2898,11 +3702,17 @@ void initpassdb(void)
 	}
 
 	dom_sid_Type = (PyTypeObject *)PyObject_GetAttrString(mod, "dom_sid");
-	Py_DECREF(mod);
 	if (dom_sid_Type == NULL) {
 		return;
 	}
 
+	/* Import security_descriptor type from dcerpc.security */
+	security_Type = (PyTypeObject *)PyObject_GetAttrString(mod, "descriptor");
+	Py_DECREF(mod);
+	if (security_Type == NULL) {
+		return;
+	}
+
 	/* Import GUID type from dcerpc.misc */
 	mod = PyImport_ImportModule("samba.dcerpc.misc");
 	if (mod == NULL) {