2 Python wrappers for DCERPC/SMB client routines.
4 Copyright (C) Tim Potter, 2002
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
20 #include "python/py_lsa.h"
22 PyObject *new_lsa_policy_hnd_object(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
25 lsa_policy_hnd_object *o;
27 o = PyObject_New(lsa_policy_hnd_object, &lsa_policy_hnd_type);
31 memcpy(&o->pol, pol, sizeof(POLICY_HND));
37 * Exceptions raised by this module
40 PyObject *lsa_error; /* This indicates a non-RPC related error
41 such as name lookup failure */
43 PyObject *lsa_ntstatus; /* This exception is raised when a RPC call
44 returns a status code other than
48 * Open/close lsa handles
51 static PyObject *lsa_open_policy(PyObject *self, PyObject *args,
54 static char *kwlist[] = { "servername", "creds", "access", NULL };
55 char *server, *errstr;
56 PyObject *creds = NULL, *result = NULL;
57 uint32 desired_access = GENERIC_EXECUTE_ACCESS;
58 struct cli_state *cli = NULL;
60 TALLOC_CTX *mem_ctx = NULL;
63 if (!PyArg_ParseTupleAndKeywords(
64 args, kw, "s|Oi", kwlist, &server, &creds, &desired_access))
67 if (creds && creds != Py_None && !PyDict_Check(creds)) {
68 PyErr_SetString(PyExc_TypeError,
69 "credentials must be dictionary or None");
73 if (server[0] != '\\' || server[1] != '\\') {
74 PyErr_SetString(PyExc_ValueError, "UNC name required");
80 if (!(cli = open_pipe_creds(server, creds, PI_LSARPC, &errstr))) {
81 PyErr_SetString(lsa_error, errstr);
86 if (!(mem_ctx = talloc_init("lsa_open_policy"))) {
87 PyErr_SetString(lsa_error, "unable to init talloc context\n");
91 ntstatus = rpccli_lsa_open_policy(
92 cli->pipe_list, mem_ctx, True, desired_access, &hnd);
94 if (!NT_STATUS_IS_OK(ntstatus)) {
95 PyErr_SetObject(lsa_ntstatus, py_ntstatus_tuple(ntstatus));
99 result = new_lsa_policy_hnd_object(cli->pipe_list, mem_ctx, &hnd);
106 talloc_destroy(mem_ctx);
112 static PyObject *lsa_close(PyObject *self, PyObject *args, PyObject *kw)
115 lsa_policy_hnd_object *hnd;
118 /* Parse parameters */
120 if (!PyArg_ParseTuple(args, "O!", &lsa_policy_hnd_type, &po))
123 hnd = (lsa_policy_hnd_object *)po;
125 /* Call rpc function */
127 result = rpccli_lsa_Close(hnd->cli, hnd->mem_ctx, &hnd->pol);
129 /* Cleanup samba stuff */
131 cli_shutdown(hnd->cli);
132 talloc_destroy(hnd->mem_ctx);
140 static PyObject *lsa_lookup_names(PyObject *self, PyObject *args)
142 PyObject *py_names, *result = NULL;
144 lsa_policy_hnd_object *hnd = (lsa_policy_hnd_object *)self;
148 TALLOC_CTX *mem_ctx = NULL;
149 enum lsa_SidType *name_types;
151 if (!PyArg_ParseTuple(args, "O", &py_names))
154 if (!PyList_Check(py_names) && !PyString_Check(py_names)) {
155 PyErr_SetString(PyExc_TypeError, "must be list or string");
159 if (!(mem_ctx = talloc_init("lsa_lookup_names"))) {
160 PyErr_SetString(lsa_error, "unable to init talloc context\n");
164 if (PyList_Check(py_names)) {
166 /* Convert list to char ** array */
168 num_names = PyList_Size(py_names);
169 names = (const char **)_talloc(mem_ctx, num_names * sizeof(char *));
171 for (i = 0; i < num_names; i++) {
172 PyObject *obj = PyList_GetItem(py_names, i);
174 names[i] = talloc_strdup(mem_ctx, PyString_AsString(obj));
179 /* Just a single element */
182 names = (const char **)_talloc(mem_ctx, sizeof(char *));
184 names[0] = PyString_AsString(py_names);
187 ntstatus = rpccli_lsa_lookup_names(
188 hnd->cli, mem_ctx, &hnd->pol, num_names, names,
189 NULL, 1, &sids, &name_types);
191 if (!NT_STATUS_IS_OK(ntstatus) && NT_STATUS_V(ntstatus) != 0x107) {
192 PyErr_SetObject(lsa_ntstatus, py_ntstatus_tuple(ntstatus));
196 result = PyList_New(num_names);
198 for (i = 0; i < num_names; i++) {
199 PyObject *sid_obj, *obj;
201 py_from_SID(&sid_obj, &sids[i]);
203 obj = Py_BuildValue("(Ni)", sid_obj, name_types[i]);
205 PyList_SetItem(result, i, obj);
209 talloc_destroy(mem_ctx);
214 static PyObject *lsa_lookup_sids(PyObject *self, PyObject *args,
217 PyObject *py_sids, *result = NULL;
220 char **domains, **names;
222 lsa_policy_hnd_object *hnd = (lsa_policy_hnd_object *)self;
223 TALLOC_CTX *mem_ctx = NULL;
226 if (!PyArg_ParseTuple(args, "O", &py_sids))
229 if (!PyList_Check(py_sids) && !PyString_Check(py_sids)) {
230 PyErr_SetString(PyExc_TypeError, "must be list or string");
234 if (!(mem_ctx = talloc_init("lsa_lookup_sids"))) {
235 PyErr_SetString(lsa_error, "unable to init talloc context\n");
239 if (PyList_Check(py_sids)) {
241 /* Convert dictionary to char ** array */
243 num_sids = PyList_Size(py_sids);
244 sids = (DOM_SID *)_talloc(mem_ctx, num_sids * sizeof(DOM_SID));
246 memset(sids, 0, num_sids * sizeof(DOM_SID));
248 for (i = 0; i < num_sids; i++) {
249 PyObject *obj = PyList_GetItem(py_sids, i);
251 if (!string_to_sid(&sids[i], PyString_AsString(obj))) {
252 PyErr_SetString(PyExc_ValueError, "string_to_sid failed");
259 /* Just a single element */
262 sids = (DOM_SID *)_talloc(mem_ctx, sizeof(DOM_SID));
264 if (!string_to_sid(&sids[0], PyString_AsString(py_sids))) {
265 PyErr_SetString(PyExc_ValueError, "string_to_sid failed");
270 ntstatus = rpccli_lsa_lookup_sids(
271 hnd->cli, mem_ctx, &hnd->pol, num_sids, sids, &domains,
274 if (!NT_STATUS_IS_OK(ntstatus)) {
275 PyErr_SetObject(lsa_ntstatus, py_ntstatus_tuple(ntstatus));
279 result = PyList_New(num_sids);
281 for (i = 0; i < num_sids; i++) {
284 obj = Py_BuildValue("{sssssi}", "username", names[i],
285 "domain", domains[i], "name_type",
288 PyList_SetItem(result, i, obj);
292 talloc_destroy(mem_ctx);
297 static PyObject *lsa_enum_trust_dom(PyObject *self, PyObject *args)
299 lsa_policy_hnd_object *hnd = (lsa_policy_hnd_object *)self;
301 uint32 enum_ctx = 0, num_domains, i;
303 DOM_SID *domain_sids;
306 if (!PyArg_ParseTuple(args, ""))
309 ntstatus = rpccli_lsa_enum_trust_dom(
310 hnd->cli, hnd->mem_ctx, &hnd->pol, &enum_ctx,
311 &num_domains, &domain_names, &domain_sids);
313 if (!NT_STATUS_IS_OK(ntstatus)) {
314 PyErr_SetObject(lsa_ntstatus, py_ntstatus_tuple(ntstatus));
318 result = PyList_New(num_domains);
320 for (i = 0; i < num_domains; i++) {
323 sid_to_string(sid_str, &domain_sids[i]);
326 Py_BuildValue("(ss)", domain_names[i], sid_str));
333 * Method dispatch tables
336 static PyMethodDef lsa_hnd_methods[] = {
340 { "lookup_sids", (PyCFunction)lsa_lookup_sids,
341 METH_VARARGS | METH_KEYWORDS,
342 "Convert sids to names." },
344 { "lookup_names", (PyCFunction)lsa_lookup_names,
345 METH_VARARGS | METH_KEYWORDS,
346 "Convert names to sids." },
348 /* Trusted domains */
350 { "enum_trusted_domains", (PyCFunction)lsa_enum_trust_dom,
352 "Enumerate trusted domains." },
357 static void py_lsa_policy_hnd_dealloc(PyObject* self)
362 static PyObject *py_lsa_policy_hnd_getattr(PyObject *self, char *attrname)
364 return Py_FindMethod(lsa_hnd_methods, self, attrname);
367 PyTypeObject lsa_policy_hnd_type = {
368 PyObject_HEAD_INIT(NULL)
371 sizeof(lsa_policy_hnd_object),
373 py_lsa_policy_hnd_dealloc, /*tp_dealloc*/
375 py_lsa_policy_hnd_getattr, /*tp_getattr*/
380 0, /*tp_as_sequence*/
385 static PyMethodDef lsa_methods[] = {
387 /* Open/close lsa handles */
389 { "open_policy", (PyCFunction)lsa_open_policy,
390 METH_VARARGS | METH_KEYWORDS,
391 "Open a policy handle" },
393 { "close", (PyCFunction)lsa_close,
395 "Close a policy handle" },
397 /* Other stuff - this should really go into a samba config module
398 but for the moment let's leave it here. */
400 { "setup_logging", (PyCFunction)py_setup_logging,
401 METH_VARARGS | METH_KEYWORDS,
402 "Set up debug logging.\n"
404 "Initialises Samba's debug logging system. One argument is expected which\n"
405 "is a boolean specifying whether debugging is interactive and sent to stdout\n"
406 "or logged to a file.\n"
410 ">>> lsa.setup_logging(interactive = 1)" },
412 { "get_debuglevel", (PyCFunction)get_debuglevel,
414 "Set the current debug level.\n"
418 ">>> lsa.get_debuglevel()\n"
421 { "set_debuglevel", (PyCFunction)set_debuglevel,
423 "Get the current debug level.\n"
427 ">>> lsa.set_debuglevel(10)" },
432 static struct const_vals {
435 } module_const_vals[] = {
439 static void const_init(PyObject *dict)
441 struct const_vals *tmp;
444 for (tmp = module_const_vals; tmp->name; tmp++) {
445 obj = PyInt_FromLong(tmp->value);
446 PyDict_SetItemString(dict, tmp->name, obj);
452 * Module initialisation
457 PyObject *module, *dict;
459 /* Initialise module */
461 module = Py_InitModule("lsa", lsa_methods);
462 dict = PyModule_GetDict(module);
464 lsa_error = PyErr_NewException("lsa.error", NULL, NULL);
465 PyDict_SetItemString(dict, "error", lsa_error);
467 lsa_ntstatus = PyErr_NewException("lsa.ntstatus", NULL, NULL);
468 PyDict_SetItemString(dict, "ntstatus", lsa_ntstatus);
470 /* Initialise policy handle object */
472 lsa_policy_hnd_type.ob_type = &PyType_Type;
474 /* Initialise constants */
478 /* Do samba initialisation */
482 setup_logging("lsa", True);