2 Unix SMB/CIFS implementation.
4 Python interface to DCE/RPC library - utility functions.
6 Copyright (C) 2010 Jelmer Vernooij <jelmer@samba.org>
7 Copyright (C) 2010 Andrew Tridgell <tridge@samba.org>
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #include "python/py3compat.h"
26 #include "python/modules.h"
27 #include "librpc/rpc/pyrpc_util.h"
28 #include "librpc/rpc/dcerpc.h"
29 #include "librpc/rpc/pyrpc.h"
30 #include "param/pyparam.h"
31 #include "auth/credentials/pycredentials.h"
32 #include "lib/events/events.h"
33 #include "lib/messaging/messaging.h"
34 #include "lib/messaging/irpc.h"
36 bool py_check_dcerpc_type(PyObject *obj, const char *module, const char *type_name)
42 mod = PyImport_ImportModule(module);
45 PyErr_Format(PyExc_RuntimeError, "Unable to import %s to check type %s",
50 type = (PyTypeObject *)PyObject_GetAttrString(mod, type_name);
53 PyErr_Format(PyExc_RuntimeError, "Unable to find type %s in module %s",
58 ret = PyObject_TypeCheck(obj, type);
62 PyErr_Format(PyExc_TypeError, "Expected type %s.%s, got %s",
63 module, type_name, Py_TYPE(obj)->tp_name);
69 connect to a IRPC pipe from python
71 static NTSTATUS pyrpc_irpc_connect(TALLOC_CTX *mem_ctx, const char *irpc_server,
72 const struct ndr_interface_table *table,
73 struct tevent_context *event_ctx,
74 struct loadparm_context *lp_ctx,
75 struct dcerpc_binding_handle **binding_handle)
77 struct imessaging_context *msg;
79 msg = imessaging_client_init(mem_ctx, lp_ctx, event_ctx);
80 NT_STATUS_HAVE_NO_MEMORY(msg);
82 *binding_handle = irpc_binding_handle_by_name(mem_ctx, msg, irpc_server, table);
83 if (*binding_handle == NULL) {
85 return NT_STATUS_INVALID_PIPE_STATE;
89 * Note: this allows nested event loops to happen,
90 * but as there's no top level event loop it's not that critical.
92 dcerpc_binding_handle_set_sync_ev(*binding_handle, event_ctx);
97 PyObject *py_dcerpc_interface_init_helper(PyTypeObject *type, PyObject *args, PyObject *kwargs,
98 const struct ndr_interface_table *table)
100 dcerpc_InterfaceObject *ret;
101 const char *binding_string;
102 PyObject *py_lp_ctx = Py_None, *py_credentials = Py_None, *py_basis = Py_None;
104 unsigned int timeout = (unsigned int)-1;
105 const char *kwnames[] = {
106 "binding", "lp_ctx", "credentials", "timeout", "basis_connection", NULL
109 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|OOIO:samr", discard_const_p(char *, kwnames), &binding_string, &py_lp_ctx, &py_credentials, &timeout, &py_basis)) {
113 status = dcerpc_init();
114 if (!NT_STATUS_IS_OK(status)) {
115 PyErr_SetNTSTATUS(status);
119 ret = PyObject_New(dcerpc_InterfaceObject, type);
126 ret->binding_handle = NULL;
128 ret->mem_ctx = talloc_new(NULL);
129 if (ret->mem_ctx == NULL) {
134 if (strncmp(binding_string, "irpc:", 5) == 0) {
135 struct loadparm_context *lp_ctx;
137 ret->ev = s4_event_context_init(ret->mem_ctx);
138 if (ret->ev == NULL) {
139 PyErr_SetString(PyExc_TypeError,
140 "Unable to initialise event context");
145 lp_ctx = lpcfg_from_py_object(ret->ev, py_lp_ctx);
146 if (lp_ctx == NULL) {
147 PyErr_SetString(PyExc_TypeError, "Expected loadparm context");
152 status = pyrpc_irpc_connect(ret->mem_ctx, binding_string+5, table,
153 ret->ev, lp_ctx, &ret->binding_handle);
154 if (!NT_STATUS_IS_OK(status)) {
155 PyErr_SetNTSTATUS(status);
159 } else if (py_basis != Py_None) {
160 struct dcerpc_pipe *base_pipe;
162 PyTypeObject *ClientConnection_Type;
164 py_base = PyImport_ImportModule("samba.dcerpc.base");
165 if (py_base == NULL) {
170 ClientConnection_Type = (PyTypeObject *)PyObject_GetAttrString(py_base, "ClientConnection");
171 if (ClientConnection_Type == NULL) {
172 PyErr_SetNone(PyExc_TypeError);
178 if (!PyObject_TypeCheck(py_basis, ClientConnection_Type)) {
179 PyErr_SetString(PyExc_TypeError, "basis_connection must be a DCE/RPC connection");
182 Py_DECREF(ClientConnection_Type);
186 base_pipe = talloc_reference(ret->mem_ctx,
187 ((dcerpc_InterfaceObject *)py_basis)->pipe);
188 if (base_pipe == NULL) {
192 Py_DECREF(ClientConnection_Type);
196 ret->ev = talloc_reference(
198 ((dcerpc_InterfaceObject *)py_basis)->ev);
199 if (ret->ev == NULL) {
203 Py_DECREF(ClientConnection_Type);
207 status = dcerpc_secondary_context(base_pipe, &ret->pipe, table);
208 if (!NT_STATUS_IS_OK(status)) {
209 PyErr_SetNTSTATUS(status);
212 Py_DECREF(ClientConnection_Type);
216 ret->pipe = talloc_steal(ret->mem_ctx, ret->pipe);
217 Py_XDECREF(ClientConnection_Type);
220 struct loadparm_context *lp_ctx;
221 struct cli_credentials *credentials;
223 ret->ev = s4_event_context_init(ret->mem_ctx);
224 if (ret->ev == NULL) {
225 PyErr_SetString(PyExc_TypeError, "Expected loadparm context");
230 lp_ctx = lpcfg_from_py_object(ret->ev, py_lp_ctx);
231 if (lp_ctx == NULL) {
232 PyErr_SetString(PyExc_TypeError, "Expected loadparm context");
237 credentials = cli_credentials_from_py_object(py_credentials);
238 if (credentials == NULL) {
239 PyErr_SetString(PyExc_TypeError, "Expected credentials");
243 status = dcerpc_pipe_connect(ret->mem_ctx, &ret->pipe, binding_string,
244 table, credentials, ret->ev, lp_ctx);
245 if (!NT_STATUS_IS_OK(status)) {
246 PyErr_SetNTSTATUS(status);
253 ret->pipe->conn->flags |= DCERPC_NDR_REF_ALLOC;
254 ret->binding_handle = ret->pipe->binding_handle;
257 /* reset timeout for the handle */
258 if ((timeout != ((unsigned int)-1)) && (ret->binding_handle != NULL)) {
259 dcerpc_binding_handle_set_timeout(ret->binding_handle, timeout);
262 return (PyObject *)ret;
265 static PyObject *py_dcerpc_run_function(dcerpc_InterfaceObject *iface,
266 const struct PyNdrRpcMethodDef *md,
267 PyObject *args, PyObject *kwargs)
272 PyObject *result = Py_None;
274 if (md->pack_in_data == NULL || md->unpack_out_data == NULL) {
275 PyErr_SetString(PyExc_NotImplementedError, "No marshalling code available yet");
279 mem_ctx = talloc_new(NULL);
280 if (mem_ctx == NULL) {
285 r = talloc_zero_size(mem_ctx, md->table->calls[md->opnum].struct_size);
291 if (!md->pack_in_data(args, kwargs, r)) {
292 talloc_free(mem_ctx);
296 status = md->call(iface->binding_handle, mem_ctx, r);
297 if (!NT_STATUS_IS_OK(status)) {
298 PyErr_SetDCERPCStatus(iface->pipe, status);
299 talloc_free(mem_ctx);
303 result = md->unpack_out_data(r);
305 talloc_free(mem_ctx);
309 static PyObject *py_dcerpc_call_wrapper(PyObject *self, PyObject *args, void *wrapped, PyObject *kwargs)
311 dcerpc_InterfaceObject *iface = (dcerpc_InterfaceObject *)self;
312 const struct PyNdrRpcMethodDef *md = (const struct PyNdrRpcMethodDef *)wrapped;
314 return py_dcerpc_run_function(iface, md, args, kwargs);
317 bool PyInterface_AddNdrRpcMethods(PyTypeObject *ifacetype, const struct PyNdrRpcMethodDef *mds)
320 for (i = 0; mds[i].name; i++) {
322 struct wrapperbase *wb = (struct wrapperbase *)calloc(sizeof(struct wrapperbase), 1);
327 wb->name = discard_const_p(char, mds[i].name);
328 wb->flags = PyWrapperFlag_KEYWORDS;
329 wb->wrapper = PY_DISCARD_FUNC_SIG(wrapperfunc,
330 py_dcerpc_call_wrapper);
331 wb->doc = discard_const_p(char, mds[i].doc);
333 ret = PyDescr_NewWrapper(ifacetype, wb, discard_const_p(void, &mds[i]));
335 PyDict_SetItemString(ifacetype->tp_dict, mds[i].name,
343 PyObject *py_dcerpc_syntax_init_helper(PyTypeObject *type, PyObject *args, PyObject *kwargs,
344 const struct ndr_syntax_id *syntax)
347 struct ndr_syntax_id *obj;
348 const char *kwnames[] = { NULL };
350 if (!PyArg_ParseTupleAndKeywords(args, kwargs, ":abstract_syntax", discard_const_p(char *, kwnames))) {
354 ret = pytalloc_new(struct ndr_syntax_id, type);
359 obj = pytalloc_get_type(ret, struct ndr_syntax_id);
365 void PyErr_SetDCERPCStatus(struct dcerpc_pipe *p, NTSTATUS status)
367 PyErr_SetNTSTATUS(status);
372 take a NDR structure that has a type in a python module and return
373 it as a python object
375 r is the NDR structure pointer (a C structure)
377 r_ctx is the context that is a parent of r. It will be referenced by
378 the resulting python object
380 This MUST only be used by objects that are based on pytalloc_Object
381 otherwise the pytalloc_reference_ex() will fail.
383 PyObject *py_return_ndr_struct(const char *module_name, const char *type_name,
384 TALLOC_CTX *r_ctx, void *r)
386 PyTypeObject *py_type;
388 PyObject *result = NULL;
394 module = PyImport_ImportModule(module_name);
395 if (module == NULL) {
399 py_type = (PyTypeObject *)PyObject_GetAttrString(module, type_name);
400 if (py_type == NULL) {
405 result = pytalloc_reference_ex(py_type, r_ctx, r);
411 PyObject *PyString_FromStringOrNULL(const char *str)
416 return PyStr_FromString(str);
419 PyObject *pyrpc_import_union(PyTypeObject *type, TALLOC_CTX *mem_ctx, int level,
420 const void *in, const char *typename)
422 PyObject *mem_ctx_obj = NULL;
423 PyObject *in_obj = NULL;
424 PyObject *ret = NULL;
426 mem_ctx_obj = pytalloc_GenericObject_reference(mem_ctx);
427 if (mem_ctx_obj == NULL) {
431 in_obj = pytalloc_GenericObject_reference_ex(mem_ctx, discard_const(in));
432 if (in_obj == NULL) {
433 Py_XDECREF(mem_ctx_obj);
437 ret = PyObject_CallMethod((PyObject *)type,
438 discard_const_p(char, "__import__"),
439 discard_const_p(char, "OiO"),
440 mem_ctx_obj, level, in_obj);
441 Py_XDECREF(mem_ctx_obj);
450 void *pyrpc_export_union(PyTypeObject *type, TALLOC_CTX *mem_ctx, int level,
451 PyObject *in, const char *typename)
453 PyObject *mem_ctx_obj = NULL;
454 PyObject *ret_obj = NULL;
457 mem_ctx_obj = pytalloc_GenericObject_reference(mem_ctx);
458 if (mem_ctx_obj == NULL) {
462 ret_obj = PyObject_CallMethod((PyObject *)type,
463 discard_const_p(char, "__export__"),
464 discard_const_p(char, "OiO"),
465 mem_ctx_obj, level, in);
466 Py_XDECREF(mem_ctx_obj);
467 if (ret_obj == NULL) {
471 ret = _pytalloc_get_type(ret_obj, typename);
476 PyObject *py_dcerpc_ndr_pointer_deref(PyTypeObject *type, PyObject *obj)
478 if (!PyObject_TypeCheck(obj, type)) {
479 PyErr_Format(PyExc_TypeError,
480 "Expected type '%s' but got type '%s'",
481 (type)->tp_name, Py_TYPE(obj)->tp_name);
485 return PyObject_GetAttrString(obj, discard_const_p(char, "value"));
488 PyObject *py_dcerpc_ndr_pointer_wrap(PyTypeObject *type, PyObject *obj)
490 PyObject *args = NULL;
491 PyObject *ret_obj = NULL;
493 args = PyTuple_New(1);
498 PyTuple_SetItem(args, 0, obj);
500 ret_obj = PyObject_Call((PyObject *)type, args, NULL);