static PyObject *py_creds_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
- pytalloc_Object *ret = (pytalloc_Object *)type->tp_alloc(type, 0);
- if (ret == NULL) {
- PyErr_NoMemory();
- return NULL;
- }
- ret->talloc_ctx = talloc_new(NULL);
- if (ret->talloc_ctx == NULL) {
- PyErr_NoMemory();
- return NULL;
- }
- ret->ptr = cli_credentials_init(ret->talloc_ctx);
- return (PyObject *)ret;
+ return pytalloc_steal(type, cli_credentials_init(NULL));
}
-static PyObject *py_creds_get_username(pytalloc_Object *self)
+static PyObject *py_creds_get_username(PyObject *self, PyObject *unused)
{
return PyString_FromStringOrNULL(cli_credentials_get_username(PyCredentials_AsCliCredentials(self)));
}
-static PyObject *py_creds_set_username(pytalloc_Object *self, PyObject *args)
+static PyObject *py_creds_set_username(PyObject *self, PyObject *args)
{
char *newval;
enum credentials_obtained obt = CRED_SPECIFIED;
return PyBool_FromLong(cli_credentials_set_username(PyCredentials_AsCliCredentials(self), newval, obt));
}
-static PyObject *py_creds_get_password(pytalloc_Object *self)
+static PyObject *py_creds_get_ntlm_username_domain(PyObject *self, PyObject *unused)
{
- return PyString_FromStringOrNULL(cli_credentials_get_password(PyCredentials_AsCliCredentials(self)));
+ TALLOC_CTX *frame = talloc_stackframe();
+ const char *user = NULL;
+ const char *domain = NULL;
+ PyObject *ret = NULL;
+ cli_credentials_get_ntlm_username_domain(PyCredentials_AsCliCredentials(self),
+ frame, &user, &domain);
+ ret = Py_BuildValue("(OO)",
+ PyString_FromStringOrNULL(user),
+ PyString_FromStringOrNULL(domain));
+ TALLOC_FREE(frame);
+ return ret;
+}
+
+static PyObject *py_creds_get_principal(PyObject *self, PyObject *unused)
+{
+ TALLOC_CTX *frame = talloc_stackframe();
+ PyObject *ret = PyString_FromStringOrNULL(cli_credentials_get_principal(PyCredentials_AsCliCredentials(self), frame));
+ TALLOC_FREE(frame);
+ return ret;
+}
+
+static PyObject *py_creds_set_principal(PyObject *self, PyObject *args)
+{
+ char *newval;
+ enum credentials_obtained obt = CRED_SPECIFIED;
+ int _obt = obt;
+
+ if (!PyArg_ParseTuple(args, "s|i", &newval, &_obt)) {
+ return NULL;
+ }
+ obt = _obt;
+
+ return PyBool_FromLong(cli_credentials_set_principal(PyCredentials_AsCliCredentials(self), newval, obt));
}
+static PyObject *py_creds_get_password(PyObject *self, PyObject *unused)
+{
+ return PyString_FromStringOrNULL(cli_credentials_get_password(PyCredentials_AsCliCredentials(self)));
+}
-static PyObject *py_creds_set_password(pytalloc_Object *self, PyObject *args)
+static PyObject *py_creds_set_password(PyObject *self, PyObject *args)
{
char *newval;
enum credentials_obtained obt = CRED_SPECIFIED;
return PyBool_FromLong(cli_credentials_set_password(PyCredentials_AsCliCredentials(self), newval, obt));
}
-static PyObject *py_creds_get_domain(pytalloc_Object *self)
+static PyObject *py_creds_set_utf16_password(PyObject *self, PyObject *args)
+{
+ enum credentials_obtained obt = CRED_SPECIFIED;
+ int _obt = obt;
+ PyObject *newval = NULL;
+ DATA_BLOB blob = data_blob_null;
+ Py_ssize_t size = 0;
+ int result;
+ bool ok;
+
+ if (!PyArg_ParseTuple(args, "O|i", &newval, &_obt)) {
+ return NULL;
+ }
+ obt = _obt;
+
+ result = PyBytes_AsStringAndSize(newval, (char **)&blob.data, &size);
+ if (result != 0) {
+ PyErr_SetString(PyExc_RuntimeError, "Failed to convert passed value to Bytes");
+ return NULL;
+ }
+ blob.length = size;
+
+ ok = cli_credentials_set_utf16_password(PyCredentials_AsCliCredentials(self),
+ &blob, obt);
+
+ return PyBool_FromLong(ok);
+}
+
+static PyObject *py_creds_get_old_password(PyObject *self, PyObject *unused)
+{
+ return PyString_FromStringOrNULL(cli_credentials_get_old_password(PyCredentials_AsCliCredentials(self)));
+}
+
+static PyObject *py_creds_set_old_password(PyObject *self, PyObject *args)
+{
+ char *oldval;
+ enum credentials_obtained obt = CRED_SPECIFIED;
+ int _obt = obt;
+
+ if (!PyArg_ParseTuple(args, "s|i", &oldval, &_obt)) {
+ return NULL;
+ }
+ obt = _obt;
+
+ return PyBool_FromLong(cli_credentials_set_old_password(PyCredentials_AsCliCredentials(self), oldval, obt));
+}
+
+static PyObject *py_creds_set_old_utf16_password(PyObject *self, PyObject *args)
+{
+ PyObject *oldval = NULL;
+ DATA_BLOB blob = data_blob_null;
+ Py_ssize_t size = 0;
+ int result;
+ bool ok;
+
+ if (!PyArg_ParseTuple(args, "O", &oldval)) {
+ return NULL;
+ }
+
+ result = PyBytes_AsStringAndSize(oldval, (char **)&blob.data, &size);
+ if (result != 0) {
+ PyErr_SetString(PyExc_RuntimeError, "Failed to convert passed value to Bytes");
+ return NULL;
+ }
+ blob.length = size;
+
+ ok = cli_credentials_set_old_utf16_password(PyCredentials_AsCliCredentials(self),
+ &blob);
+
+ return PyBool_FromLong(ok);
+}
+
+static PyObject *py_creds_get_domain(PyObject *self, PyObject *unused)
{
return PyString_FromStringOrNULL(cli_credentials_get_domain(PyCredentials_AsCliCredentials(self)));
}
-static PyObject *py_creds_set_domain(pytalloc_Object *self, PyObject *args)
+static PyObject *py_creds_set_domain(PyObject *self, PyObject *args)
{
char *newval;
enum credentials_obtained obt = CRED_SPECIFIED;
return PyBool_FromLong(cli_credentials_set_domain(PyCredentials_AsCliCredentials(self), newval, obt));
}
-static PyObject *py_creds_get_realm(pytalloc_Object *self)
+static PyObject *py_creds_get_realm(PyObject *self, PyObject *unused)
{
return PyString_FromStringOrNULL(cli_credentials_get_realm(PyCredentials_AsCliCredentials(self)));
}
-static PyObject *py_creds_set_realm(pytalloc_Object *self, PyObject *args)
+static PyObject *py_creds_set_realm(PyObject *self, PyObject *args)
{
char *newval;
enum credentials_obtained obt = CRED_SPECIFIED;
return PyBool_FromLong(cli_credentials_set_realm(PyCredentials_AsCliCredentials(self), newval, obt));
}
-static PyObject *py_creds_get_bind_dn(pytalloc_Object *self)
+static PyObject *py_creds_get_bind_dn(PyObject *self, PyObject *unused)
{
return PyString_FromStringOrNULL(cli_credentials_get_bind_dn(PyCredentials_AsCliCredentials(self)));
}
-static PyObject *py_creds_set_bind_dn(pytalloc_Object *self, PyObject *args)
+static PyObject *py_creds_set_bind_dn(PyObject *self, PyObject *args)
{
char *newval;
if (!PyArg_ParseTuple(args, "s", &newval))
return PyBool_FromLong(cli_credentials_set_bind_dn(PyCredentials_AsCliCredentials(self), newval));
}
-static PyObject *py_creds_get_workstation(pytalloc_Object *self)
+static PyObject *py_creds_get_workstation(PyObject *self, PyObject *unused)
{
return PyString_FromStringOrNULL(cli_credentials_get_workstation(PyCredentials_AsCliCredentials(self)));
}
-static PyObject *py_creds_set_workstation(pytalloc_Object *self, PyObject *args)
+static PyObject *py_creds_set_workstation(PyObject *self, PyObject *args)
{
char *newval;
enum credentials_obtained obt = CRED_SPECIFIED;
return PyBool_FromLong(cli_credentials_set_workstation(PyCredentials_AsCliCredentials(self), newval, obt));
}
-static PyObject *py_creds_is_anonymous(pytalloc_Object *self)
+static PyObject *py_creds_is_anonymous(PyObject *self, PyObject *unused)
{
return PyBool_FromLong(cli_credentials_is_anonymous(PyCredentials_AsCliCredentials(self)));
}
-static PyObject *py_creds_set_anonymous(pytalloc_Object *self)
+static PyObject *py_creds_set_anonymous(PyObject *self, PyObject *unused)
{
cli_credentials_set_anonymous(PyCredentials_AsCliCredentials(self));
Py_RETURN_NONE;
}
-static PyObject *py_creds_authentication_requested(pytalloc_Object *self)
+static PyObject *py_creds_authentication_requested(PyObject *self, PyObject *unused)
{
return PyBool_FromLong(cli_credentials_authentication_requested(PyCredentials_AsCliCredentials(self)));
}
-static PyObject *py_creds_wrong_password(pytalloc_Object *self)
+static PyObject *py_creds_wrong_password(PyObject *self, PyObject *unused)
{
return PyBool_FromLong(cli_credentials_wrong_password(PyCredentials_AsCliCredentials(self)));
}
-static PyObject *py_creds_set_cmdline_callbacks(pytalloc_Object *self)
+static PyObject *py_creds_set_cmdline_callbacks(PyObject *self, PyObject *unused)
{
return PyBool_FromLong(cli_credentials_set_cmdline_callbacks(PyCredentials_AsCliCredentials(self)));
}
-static PyObject *py_creds_parse_string(pytalloc_Object *self, PyObject *args)
+static PyObject *py_creds_parse_string(PyObject *self, PyObject *args)
{
char *newval;
enum credentials_obtained obt = CRED_SPECIFIED;
Py_RETURN_NONE;
}
-static PyObject *py_creds_get_nt_hash(pytalloc_Object *self)
+static PyObject *py_creds_parse_file(PyObject *self, PyObject *args)
{
- const struct samr_Password *ntpw = cli_credentials_get_nt_hash(PyCredentials_AsCliCredentials(self), self->ptr);
+ char *newval;
+ enum credentials_obtained obt = CRED_SPECIFIED;
+ int _obt = obt;
- return PyString_FromStringAndSize(discard_const_p(char, ntpw->hash), 16);
+ if (!PyArg_ParseTuple(args, "s|i", &newval, &_obt)) {
+ return NULL;
+ }
+ obt = _obt;
+
+ cli_credentials_parse_file(PyCredentials_AsCliCredentials(self), newval, obt);
+ Py_RETURN_NONE;
}
-static PyObject *py_creds_get_kerberos_state(pytalloc_Object *self)
+static PyObject *py_cli_credentials_set_password_will_be_nt_hash(PyObject *self, PyObject *args)
+{
+ struct cli_credentials *creds = PyCredentials_AsCliCredentials(self);
+ PyObject *py_val = NULL;
+ bool val = false;
+
+ if (!PyArg_ParseTuple(args, "O!", &PyBool_Type, &py_val)) {
+ return NULL;
+ }
+ val = PyObject_IsTrue(py_val);
+
+ cli_credentials_set_password_will_be_nt_hash(creds, val);
+ Py_RETURN_NONE;
+}
+
+static PyObject *py_creds_get_nt_hash(PyObject *self, PyObject *unused)
+{
+ PyObject *ret;
+ struct cli_credentials *creds = PyCredentials_AsCliCredentials(self);
+ struct samr_Password *ntpw = cli_credentials_get_nt_hash(creds, creds);
+
+ ret = PyString_FromStringAndSize(discard_const_p(char, ntpw->hash), 16);
+ TALLOC_FREE(ntpw);
+ return ret;
+}
+
+static PyObject *py_creds_get_kerberos_state(PyObject *self, PyObject *unused)
{
int state = cli_credentials_get_kerberos_state(PyCredentials_AsCliCredentials(self));
return PyInt_FromLong(state);
}
-static PyObject *py_creds_set_kerberos_state(pytalloc_Object *self, PyObject *args)
+static PyObject *py_creds_set_kerberos_state(PyObject *self, PyObject *args)
{
int state;
if (!PyArg_ParseTuple(args, "i", &state))
Py_RETURN_NONE;
}
-static PyObject *py_creds_set_krb_forwardable(pytalloc_Object *self, PyObject *args)
+static PyObject *py_creds_set_krb_forwardable(PyObject *self, PyObject *args)
{
int state;
if (!PyArg_ParseTuple(args, "i", &state))
}
-static PyObject *py_creds_get_forced_sasl_mech(pytalloc_Object *self)
+static PyObject *py_creds_get_forced_sasl_mech(PyObject *self, PyObject *unused)
{
return PyString_FromStringOrNULL(cli_credentials_get_forced_sasl_mech(PyCredentials_AsCliCredentials(self)));
}
-static PyObject *py_creds_set_forced_sasl_mech(pytalloc_Object *self, PyObject *args)
+static PyObject *py_creds_set_forced_sasl_mech(PyObject *self, PyObject *args)
{
char *newval;
enum credentials_obtained obt = CRED_SPECIFIED;
Py_RETURN_NONE;
}
-static PyObject *py_creds_guess(pytalloc_Object *self, PyObject *args)
+static PyObject *py_creds_guess(PyObject *self, PyObject *args)
{
PyObject *py_lp_ctx = Py_None;
struct loadparm_context *lp_ctx;
Py_RETURN_NONE;
}
-static PyObject *py_creds_set_machine_account(pytalloc_Object *self, PyObject *args)
+static PyObject *py_creds_set_machine_account(PyObject *self, PyObject *args)
{
PyObject *py_lp_ctx = Py_None;
struct loadparm_context *lp_ctx;
static PyObject *PyCredentialCacheContainer_from_ccache_container(struct ccache_container *ccc)
{
- PyCredentialCacheContainerObject *py_ret;
-
- if (ccc == NULL) {
- Py_RETURN_NONE;
- }
-
- py_ret = (PyCredentialCacheContainerObject *)PyCredentialCacheContainer.tp_alloc(&PyCredentialCacheContainer, 0);
- if (py_ret == NULL) {
- PyErr_NoMemory();
- return NULL;
- }
- py_ret->mem_ctx = talloc_new(NULL);
- py_ret->ccc = talloc_reference(py_ret->mem_ctx, ccc);
- return (PyObject *)py_ret;
+ return pytalloc_reference(&PyCredentialCacheContainer, ccc);
}
-static PyObject *py_creds_get_named_ccache(pytalloc_Object *self, PyObject *args)
+static PyObject *py_creds_get_named_ccache(PyObject *self, PyObject *args)
{
PyObject *py_lp_ctx = Py_None;
char *ccache_name;
return NULL;
}
-static PyObject *py_creds_set_gensec_features(pytalloc_Object *self, PyObject *args)
+static PyObject *py_creds_set_gensec_features(PyObject *self, PyObject *args)
{
unsigned int gensec_features;
Py_RETURN_NONE;
}
-static PyObject *py_creds_get_gensec_features(pytalloc_Object *self, PyObject *args)
+static PyObject *py_creds_get_gensec_features(PyObject *self, PyObject *args)
{
unsigned int gensec_features;
static PyMethodDef py_creds_methods[] = {
- { "get_username", (PyCFunction)py_creds_get_username, METH_NOARGS,
+ { "get_username", py_creds_get_username, METH_NOARGS,
"S.get_username() -> username\nObtain username." },
- { "set_username", (PyCFunction)py_creds_set_username, METH_VARARGS,
+ { "set_username", py_creds_set_username, METH_VARARGS,
"S.set_username(name, obtained=CRED_SPECIFIED) -> None\n"
"Change username." },
- { "get_password", (PyCFunction)py_creds_get_password, METH_NOARGS,
+ { "get_principal", py_creds_get_principal, METH_NOARGS,
+ "S.get_principal() -> user@realm\nObtain user principal." },
+ { "set_principal", py_creds_set_principal, METH_VARARGS,
+ "S.set_principal(name, obtained=CRED_SPECIFIED) -> None\n"
+ "Change principal." },
+ { "get_password", py_creds_get_password, METH_NOARGS,
"S.get_password() -> password\n"
"Obtain password." },
- { "set_password", (PyCFunction)py_creds_set_password, METH_VARARGS,
+ { "get_ntlm_username_domain", py_creds_get_ntlm_username_domain, METH_NOARGS,
+ "S.get_ntlm_username_domain() -> (domain, username)\n"
+ "Obtain NTLM username and domain, split up either as (DOMAIN, user) or (\"\", \"user@realm\")." },
+ { "set_password", py_creds_set_password, METH_VARARGS,
"S.set_password(password, obtained=CRED_SPECIFIED) -> None\n"
"Change password." },
- { "get_domain", (PyCFunction)py_creds_get_domain, METH_NOARGS,
+ { "set_utf16_password", py_creds_set_utf16_password, METH_VARARGS,
+ "S.set_utf16_password(password, obtained=CRED_SPECIFIED) -> None\n"
+ "Change password." },
+ { "get_old_password", py_creds_get_old_password, METH_NOARGS,
+ "S.get_old_password() -> password\n"
+ "Obtain old password." },
+ { "set_old_password", py_creds_set_old_password, METH_VARARGS,
+ "S.set_old_password(password, obtained=CRED_SPECIFIED) -> None\n"
+ "Change old password." },
+ { "set_old_utf16_password", py_creds_set_old_utf16_password, METH_VARARGS,
+ "S.set_old_utf16_password(password, obtained=CRED_SPECIFIED) -> None\n"
+ "Change old password." },
+ { "get_domain", py_creds_get_domain, METH_NOARGS,
"S.get_domain() -> domain\n"
"Obtain domain name." },
- { "set_domain", (PyCFunction)py_creds_set_domain, METH_VARARGS,
+ { "set_domain", py_creds_set_domain, METH_VARARGS,
"S.set_domain(domain, obtained=CRED_SPECIFIED) -> None\n"
"Change domain name." },
- { "get_realm", (PyCFunction)py_creds_get_realm, METH_NOARGS,
+ { "get_realm", py_creds_get_realm, METH_NOARGS,
"S.get_realm() -> realm\n"
"Obtain realm name." },
- { "set_realm", (PyCFunction)py_creds_set_realm, METH_VARARGS,
+ { "set_realm", py_creds_set_realm, METH_VARARGS,
"S.set_realm(realm, obtained=CRED_SPECIFIED) -> None\n"
"Change realm name." },
- { "get_bind_dn", (PyCFunction)py_creds_get_bind_dn, METH_NOARGS,
+ { "get_bind_dn", py_creds_get_bind_dn, METH_NOARGS,
"S.get_bind_dn() -> bind dn\n"
"Obtain bind DN." },
- { "set_bind_dn", (PyCFunction)py_creds_set_bind_dn, METH_VARARGS,
+ { "set_bind_dn", py_creds_set_bind_dn, METH_VARARGS,
"S.set_bind_dn(bind_dn) -> None\n"
"Change bind DN." },
- { "is_anonymous", (PyCFunction)py_creds_is_anonymous, METH_NOARGS,
+ { "is_anonymous", py_creds_is_anonymous, METH_NOARGS,
NULL },
- { "set_anonymous", (PyCFunction)py_creds_set_anonymous, METH_NOARGS,
+ { "set_anonymous", py_creds_set_anonymous, METH_NOARGS,
"S.set_anonymous() -> None\n"
"Use anonymous credentials." },
- { "get_workstation", (PyCFunction)py_creds_get_workstation, METH_NOARGS,
+ { "get_workstation", py_creds_get_workstation, METH_NOARGS,
NULL },
- { "set_workstation", (PyCFunction)py_creds_set_workstation, METH_VARARGS,
+ { "set_workstation", py_creds_set_workstation, METH_VARARGS,
NULL },
- { "authentication_requested", (PyCFunction)py_creds_authentication_requested, METH_NOARGS,
+ { "authentication_requested", py_creds_authentication_requested, METH_NOARGS,
NULL },
- { "wrong_password", (PyCFunction)py_creds_wrong_password, METH_NOARGS,
+ { "wrong_password", py_creds_wrong_password, METH_NOARGS,
"S.wrong_password() -> bool\n"
"Indicate the returned password was incorrect." },
- { "set_cmdline_callbacks", (PyCFunction)py_creds_set_cmdline_callbacks, METH_NOARGS,
+ { "set_cmdline_callbacks", py_creds_set_cmdline_callbacks, METH_NOARGS,
"S.set_cmdline_callbacks() -> bool\n"
"Use command-line to obtain credentials not explicitly set." },
- { "parse_string", (PyCFunction)py_creds_parse_string, METH_VARARGS,
+ { "parse_string", py_creds_parse_string, METH_VARARGS,
"S.parse_string(text, obtained=CRED_SPECIFIED) -> None\n"
"Parse credentials string." },
- { "get_nt_hash", (PyCFunction)py_creds_get_nt_hash, METH_NOARGS,
+ { "parse_file", py_creds_parse_file, METH_VARARGS,
+ "S.parse_file(filename, obtained=CRED_SPECIFIED) -> None\n"
+ "Parse credentials file." },
+ { "set_password_will_be_nt_hash",
+ py_cli_credentials_set_password_will_be_nt_hash, METH_VARARGS,
+ "S.set_password_will_be_nt_hash(bool) -> None\n"
+ "Alters the behaviour of S.set_password() "
+ "to expect the NTHASH as hexstring." },
+ { "get_nt_hash", py_creds_get_nt_hash, METH_NOARGS,
NULL },
- { "get_kerberos_state", (PyCFunction)py_creds_get_kerberos_state, METH_NOARGS,
+ { "get_kerberos_state", py_creds_get_kerberos_state, METH_NOARGS,
NULL },
- { "set_kerberos_state", (PyCFunction)py_creds_set_kerberos_state, METH_VARARGS,
+ { "set_kerberos_state", py_creds_set_kerberos_state, METH_VARARGS,
NULL },
- { "set_krb_forwardable", (PyCFunction)py_creds_set_krb_forwardable, METH_VARARGS,
+ { "set_krb_forwardable", py_creds_set_krb_forwardable, METH_VARARGS,
NULL },
- { "guess", (PyCFunction)py_creds_guess, METH_VARARGS, NULL },
- { "set_machine_account", (PyCFunction)py_creds_set_machine_account, METH_VARARGS, NULL },
- { "get_named_ccache", (PyCFunction)py_creds_get_named_ccache, METH_VARARGS, NULL },
- { "set_gensec_features", (PyCFunction)py_creds_set_gensec_features, METH_VARARGS, NULL },
- { "get_gensec_features", (PyCFunction)py_creds_get_gensec_features, METH_NOARGS, NULL },
- { "get_forced_sasl_mech", (PyCFunction)py_creds_get_forced_sasl_mech, METH_NOARGS,
+ { "guess", py_creds_guess, METH_VARARGS, NULL },
+ { "set_machine_account", py_creds_set_machine_account, METH_VARARGS, NULL },
+ { "get_named_ccache", py_creds_get_named_ccache, METH_VARARGS, NULL },
+ { "set_gensec_features", py_creds_set_gensec_features, METH_VARARGS, NULL },
+ { "get_gensec_features", py_creds_get_gensec_features, METH_NOARGS, NULL },
+ { "get_forced_sasl_mech", py_creds_get_forced_sasl_mech, METH_NOARGS,
"S.get_forced_sasl_mech() -> SASL mechanism\nObtain forced SASL mechanism." },
- { "set_forced_sasl_mech", (PyCFunction)py_creds_set_forced_sasl_mech, METH_VARARGS,
+ { "set_forced_sasl_mech", py_creds_set_forced_sasl_mech, METH_VARARGS,
"S.set_forced_sasl_mech(name) -> None\n"
"Set forced SASL mechanism." },
{ NULL }
PyTypeObject PyCredentials = {
.tp_name = "credentials.Credentials",
- .tp_basicsize = sizeof(pytalloc_Object),
.tp_new = py_creds_new,
.tp_flags = Py_TPFLAGS_DEFAULT,
.tp_methods = py_creds_methods,
PyTypeObject PyCredentialCacheContainer = {
.tp_name = "credentials.CredentialCacheContainer",
- .tp_basicsize = sizeof(pytalloc_Object),
.tp_flags = Py_TPFLAGS_DEFAULT,
};
void initcredentials(void)
{
PyObject *m;
- PyTypeObject *talloc_type = pytalloc_GetObjectType();
- if (talloc_type == NULL)
- return;
-
- PyCredentials.tp_base = PyCredentialCacheContainer.tp_base = talloc_type;
-
- if (PyType_Ready(&PyCredentials) < 0)
+ if (pytalloc_BaseObject_PyType_Ready(&PyCredentials) < 0)
return;
- if (PyType_Ready(&PyCredentialCacheContainer) < 0)
+ if (pytalloc_BaseObject_PyType_Ready(&PyCredentialCacheContainer) < 0)
return;
m = Py_InitModule3("credentials", NULL, "Credentials management.");
git.samba.org / amitay / samba.git / blobdiff