Line data Source code
1 : /*
2 : Unix SMB/CIFS implementation.
3 :
4 : Python interface to DCE/RPC library - utility functions.
5 :
6 : Copyright (C) 2010 Jelmer Vernooij <jelmer@samba.org>
7 : Copyright (C) 2010 Andrew Tridgell <tridge@samba.org>
8 :
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.
13 :
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.
18 :
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/>.
21 : */
22 :
23 : #include <Python.h>
24 : #include "python/py3compat.h"
25 : #include "includes.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"
35 :
36 51022822 : bool py_check_dcerpc_type(PyObject *obj, const char *module, const char *type_name)
37 : {
38 : PyObject *mod;
39 : PyTypeObject *type;
40 : bool ret;
41 :
42 51022822 : mod = PyImport_ImportModule(module);
43 :
44 51022822 : if (mod == NULL) {
45 0 : PyErr_Format(PyExc_RuntimeError, "Unable to import %s to check type %s",
46 : module, type_name);
47 0 : return false;
48 : }
49 :
50 51022822 : type = (PyTypeObject *)PyObject_GetAttrString(mod, type_name);
51 51022822 : Py_DECREF(mod);
52 51022822 : if (type == NULL) {
53 0 : PyErr_Format(PyExc_RuntimeError, "Unable to find type %s in module %s",
54 : module, type_name);
55 0 : return false;
56 : }
57 :
58 51022822 : ret = PyObject_TypeCheck(obj, type);
59 51022822 : Py_DECREF(type);
60 :
61 51022822 : if (!ret)
62 2 : PyErr_Format(PyExc_TypeError, "Expected type %s.%s, got %s",
63 2 : module, type_name, Py_TYPE(obj)->tp_name);
64 :
65 44771908 : return ret;
66 : }
67 :
68 : /*
69 : connect to a IRPC pipe from python
70 : */
71 4 : 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)
76 : {
77 : struct imessaging_context *msg;
78 :
79 4 : msg = imessaging_client_init(mem_ctx, lp_ctx, event_ctx);
80 4 : NT_STATUS_HAVE_NO_MEMORY(msg);
81 :
82 4 : *binding_handle = irpc_binding_handle_by_name(mem_ctx, msg, irpc_server, table);
83 4 : if (*binding_handle == NULL) {
84 1 : talloc_free(msg);
85 1 : return NT_STATUS_INVALID_PIPE_STATE;
86 : }
87 :
88 : /*
89 : * Note: this allows nested event loops to happen,
90 : * but as there's no top level event loop it's not that critical.
91 : */
92 3 : dcerpc_binding_handle_set_sync_ev(*binding_handle, event_ctx);
93 :
94 3 : return NT_STATUS_OK;
95 : }
96 :
97 3710 : PyObject *py_dcerpc_interface_init_helper(PyTypeObject *type, PyObject *args, PyObject *kwargs,
98 : const struct ndr_interface_table *table)
99 : {
100 : dcerpc_InterfaceObject *ret;
101 : const char *binding_string;
102 3710 : PyObject *py_lp_ctx = Py_None, *py_credentials = Py_None, *py_basis = Py_None;
103 : NTSTATUS status;
104 3710 : unsigned int timeout = (unsigned int)-1;
105 3710 : const char *kwnames[] = {
106 : "binding", "lp_ctx", "credentials", "timeout", "basis_connection", NULL
107 : };
108 :
109 3710 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|OOIO:samr", discard_const_p(char *, kwnames), &binding_string, &py_lp_ctx, &py_credentials, &timeout, &py_basis)) {
110 0 : return NULL;
111 : }
112 :
113 3710 : status = dcerpc_init();
114 3710 : if (!NT_STATUS_IS_OK(status)) {
115 0 : PyErr_SetNTSTATUS(status);
116 0 : return NULL;
117 : }
118 :
119 3710 : ret = PyObject_New(dcerpc_InterfaceObject, type);
120 3710 : if (ret == NULL) {
121 0 : PyErr_NoMemory();
122 0 : return NULL;
123 : }
124 :
125 3710 : ret->pipe = NULL;
126 3710 : ret->binding_handle = NULL;
127 3710 : ret->ev = NULL;
128 3710 : ret->mem_ctx = talloc_new(NULL);
129 3710 : if (ret->mem_ctx == NULL) {
130 0 : PyErr_NoMemory();
131 0 : return NULL;
132 : }
133 :
134 3710 : if (strncmp(binding_string, "irpc:", 5) == 0) {
135 : struct loadparm_context *lp_ctx;
136 :
137 4 : ret->ev = s4_event_context_init(ret->mem_ctx);
138 4 : if (ret->ev == NULL) {
139 0 : PyErr_SetString(PyExc_TypeError,
140 : "Unable to initialise event context");
141 0 : Py_DECREF(ret);
142 0 : return NULL;
143 : }
144 :
145 4 : lp_ctx = lpcfg_from_py_object(ret->ev, py_lp_ctx);
146 4 : if (lp_ctx == NULL) {
147 0 : PyErr_SetString(PyExc_TypeError, "Expected loadparm context");
148 0 : Py_DECREF(ret);
149 0 : return NULL;
150 : }
151 :
152 4 : status = pyrpc_irpc_connect(ret->mem_ctx, binding_string+5, table,
153 : ret->ev, lp_ctx, &ret->binding_handle);
154 4 : if (!NT_STATUS_IS_OK(status)) {
155 1 : PyErr_SetNTSTATUS(status);
156 1 : Py_DECREF(ret);
157 1 : return NULL;
158 : }
159 3706 : } else if (py_basis != Py_None) {
160 : struct dcerpc_pipe *base_pipe;
161 : PyObject *py_base;
162 : PyTypeObject *ClientConnection_Type;
163 :
164 3 : py_base = PyImport_ImportModule("samba.dcerpc.base");
165 3 : if (py_base == NULL) {
166 0 : Py_DECREF(ret);
167 0 : return NULL;
168 : }
169 :
170 3 : ClientConnection_Type = (PyTypeObject *)PyObject_GetAttrString(py_base, "ClientConnection");
171 3 : if (ClientConnection_Type == NULL) {
172 0 : PyErr_SetNone(PyExc_TypeError);
173 0 : Py_DECREF(ret);
174 0 : Py_DECREF(py_base);
175 0 : return NULL;
176 : }
177 :
178 3 : if (!PyObject_TypeCheck(py_basis, ClientConnection_Type)) {
179 0 : PyErr_SetString(PyExc_TypeError, "basis_connection must be a DCE/RPC connection");
180 0 : Py_DECREF(ret);
181 0 : Py_DECREF(py_base);
182 0 : Py_DECREF(ClientConnection_Type);
183 0 : return NULL;
184 : }
185 :
186 3 : base_pipe = talloc_reference(ret->mem_ctx,
187 : ((dcerpc_InterfaceObject *)py_basis)->pipe);
188 3 : if (base_pipe == NULL) {
189 0 : PyErr_NoMemory();
190 0 : Py_DECREF(ret);
191 0 : Py_DECREF(py_base);
192 0 : Py_DECREF(ClientConnection_Type);
193 0 : return NULL;
194 : }
195 :
196 3 : ret->ev = talloc_reference(
197 : ret->mem_ctx,
198 : ((dcerpc_InterfaceObject *)py_basis)->ev);
199 3 : if (ret->ev == NULL) {
200 0 : PyErr_NoMemory();
201 0 : Py_DECREF(ret);
202 0 : Py_DECREF(py_base);
203 0 : Py_DECREF(ClientConnection_Type);
204 0 : return NULL;
205 : }
206 :
207 3 : status = dcerpc_secondary_context(base_pipe, &ret->pipe, table);
208 3 : if (!NT_STATUS_IS_OK(status)) {
209 0 : PyErr_SetNTSTATUS(status);
210 0 : Py_DECREF(ret);
211 0 : Py_DECREF(py_base);
212 0 : Py_DECREF(ClientConnection_Type);
213 0 : return NULL;
214 : }
215 :
216 3 : ret->pipe = talloc_steal(ret->mem_ctx, ret->pipe);
217 3 : Py_XDECREF(ClientConnection_Type);
218 3 : Py_XDECREF(py_base);
219 : } else {
220 : struct loadparm_context *lp_ctx;
221 : struct cli_credentials *credentials;
222 :
223 3703 : ret->ev = s4_event_context_init(ret->mem_ctx);
224 3703 : if (ret->ev == NULL) {
225 0 : PyErr_SetString(PyExc_TypeError, "Expected loadparm context");
226 0 : Py_DECREF(ret);
227 0 : return NULL;
228 : }
229 :
230 3703 : lp_ctx = lpcfg_from_py_object(ret->ev, py_lp_ctx);
231 3703 : if (lp_ctx == NULL) {
232 0 : PyErr_SetString(PyExc_TypeError, "Expected loadparm context");
233 0 : Py_DECREF(ret);
234 0 : return NULL;
235 : }
236 :
237 3703 : credentials = cli_credentials_from_py_object(py_credentials);
238 3703 : if (credentials == NULL) {
239 0 : PyErr_SetString(PyExc_TypeError, "Expected credentials");
240 0 : Py_DECREF(ret);
241 0 : return NULL;
242 : }
243 3703 : status = dcerpc_pipe_connect(ret->mem_ctx, &ret->pipe, binding_string,
244 : table, credentials, ret->ev, lp_ctx);
245 3699 : if (!NT_STATUS_IS_OK(status)) {
246 19 : PyErr_SetNTSTATUS(status);
247 19 : Py_DECREF(ret);
248 19 : return NULL;
249 : }
250 : }
251 :
252 3686 : if (ret->pipe) {
253 3683 : ret->pipe->conn->flags |= DCERPC_NDR_REF_ALLOC;
254 3683 : ret->binding_handle = ret->pipe->binding_handle;
255 : }
256 :
257 : /* reset timeout for the handle */
258 3686 : if ((timeout != ((unsigned int)-1)) && (ret->binding_handle != NULL)) {
259 0 : dcerpc_binding_handle_set_timeout(ret->binding_handle, timeout);
260 : }
261 :
262 3682 : return (PyObject *)ret;
263 : }
264 :
265 17434 : static PyObject *py_dcerpc_run_function(dcerpc_InterfaceObject *iface,
266 : const struct PyNdrRpcMethodDef *md,
267 : PyObject *args, PyObject *kwargs)
268 : {
269 : TALLOC_CTX *mem_ctx;
270 : NTSTATUS status;
271 : void *r;
272 17434 : PyObject *result = Py_None;
273 :
274 17434 : if (md->pack_in_data == NULL || md->unpack_out_data == NULL) {
275 0 : PyErr_SetString(PyExc_NotImplementedError, "No marshalling code available yet");
276 0 : return NULL;
277 : }
278 :
279 17434 : mem_ctx = talloc_new(NULL);
280 17434 : if (mem_ctx == NULL) {
281 0 : PyErr_NoMemory();
282 0 : return NULL;
283 : }
284 :
285 17434 : r = talloc_zero_size(mem_ctx, md->table->calls[md->opnum].struct_size);
286 17434 : if (r == NULL) {
287 0 : PyErr_NoMemory();
288 0 : return NULL;
289 : }
290 :
291 17434 : if (!md->pack_in_data(args, kwargs, r)) {
292 0 : talloc_free(mem_ctx);
293 0 : return NULL;
294 : }
295 :
296 17434 : status = md->call(iface->binding_handle, mem_ctx, r);
297 17434 : if (!NT_STATUS_IS_OK(status)) {
298 90 : PyErr_SetDCERPCStatus(iface->pipe, status);
299 90 : talloc_free(mem_ctx);
300 90 : return NULL;
301 : }
302 :
303 17344 : result = md->unpack_out_data(r);
304 :
305 17344 : talloc_free(mem_ctx);
306 17334 : return result;
307 : }
308 :
309 17434 : static PyObject *py_dcerpc_call_wrapper(PyObject *self, PyObject *args, void *wrapped, PyObject *kwargs)
310 : {
311 17434 : dcerpc_InterfaceObject *iface = (dcerpc_InterfaceObject *)self;
312 17434 : const struct PyNdrRpcMethodDef *md = (const struct PyNdrRpcMethodDef *)wrapped;
313 :
314 17434 : return py_dcerpc_run_function(iface, md, args, kwargs);
315 : }
316 :
317 38985 : bool PyInterface_AddNdrRpcMethods(PyTypeObject *ifacetype, const struct PyNdrRpcMethodDef *mds)
318 : {
319 : int i;
320 945910 : for (i = 0; mds[i].name; i++) {
321 : PyObject *ret;
322 906925 : struct wrapperbase *wb = (struct wrapperbase *)calloc(sizeof(struct wrapperbase), 1);
323 :
324 906925 : if (wb == NULL) {
325 0 : return false;
326 : }
327 906925 : wb->name = discard_const_p(char, mds[i].name);
328 906925 : wb->flags = PyWrapperFlag_KEYWORDS;
329 906925 : wb->wrapper = PY_DISCARD_FUNC_SIG(wrapperfunc,
330 : py_dcerpc_call_wrapper);
331 906925 : wb->doc = discard_const_p(char, mds[i].doc);
332 :
333 906925 : ret = PyDescr_NewWrapper(ifacetype, wb, discard_const_p(void, &mds[i]));
334 :
335 906925 : PyDict_SetItemString(ifacetype->tp_dict, mds[i].name,
336 : (PyObject *)ret);
337 906925 : Py_CLEAR(ret);
338 : }
339 :
340 37678 : return true;
341 : }
342 :
343 1077 : PyObject *py_dcerpc_syntax_init_helper(PyTypeObject *type, PyObject *args, PyObject *kwargs,
344 : const struct ndr_syntax_id *syntax)
345 : {
346 : PyObject *ret;
347 : struct ndr_syntax_id *obj;
348 1077 : const char *kwnames[] = { NULL };
349 :
350 1077 : if (!PyArg_ParseTupleAndKeywords(args, kwargs, ":abstract_syntax", discard_const_p(char *, kwnames))) {
351 0 : return NULL;
352 : }
353 :
354 1077 : ret = pytalloc_new(struct ndr_syntax_id, type);
355 1077 : if (ret == NULL) {
356 0 : return NULL;
357 : }
358 :
359 1077 : obj = pytalloc_get_type(ret, struct ndr_syntax_id);
360 1077 : *obj = *syntax;
361 :
362 1077 : return ret;
363 : }
364 :
365 90 : void PyErr_SetDCERPCStatus(struct dcerpc_pipe *p, NTSTATUS status)
366 : {
367 90 : if (p && NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
368 0 : status = dcerpc_fault_to_nt_status(p->last_fault_code);
369 : }
370 90 : PyErr_SetNTSTATUS(status);
371 90 : }
372 :
373 :
374 : /*
375 : take a NDR structure that has a type in a python module and return
376 : it as a python object
377 :
378 : r is the NDR structure pointer (a C structure)
379 :
380 : r_ctx is the context that is a parent of r. It will be referenced by
381 : the resulting python object
382 :
383 : This MUST only be used by objects that are based on pytalloc_Object
384 : otherwise the pytalloc_reference_ex() will fail.
385 : */
386 32724 : PyObject *py_return_ndr_struct(const char *module_name, const char *type_name,
387 : TALLOC_CTX *r_ctx, void *r)
388 : {
389 : PyTypeObject *py_type;
390 : PyObject *module;
391 32724 : PyObject *result = NULL;
392 :
393 32724 : if (r == NULL) {
394 2 : Py_RETURN_NONE;
395 : }
396 :
397 32722 : module = PyImport_ImportModule(module_name);
398 32722 : if (module == NULL) {
399 0 : return NULL;
400 : }
401 :
402 32722 : py_type = (PyTypeObject *)PyObject_GetAttrString(module, type_name);
403 32722 : if (py_type == NULL) {
404 0 : Py_DECREF(module);
405 0 : return NULL;
406 : }
407 :
408 32722 : result = pytalloc_reference_ex(py_type, r_ctx, r);
409 32722 : Py_CLEAR(module);
410 32722 : Py_CLEAR(py_type);
411 32134 : return result;
412 : }
413 :
414 191943 : PyObject *PyString_FromStringOrNULL(const char *str)
415 : {
416 191943 : if (str == NULL) {
417 87 : Py_RETURN_NONE;
418 : }
419 191856 : return PyUnicode_FromString(str);
420 : }
421 :
422 1832920 : PyObject *pyrpc_import_union(PyTypeObject *type, TALLOC_CTX *mem_ctx, int level,
423 : const void *in, const char *typename)
424 : {
425 1832920 : PyObject *mem_ctx_obj = NULL;
426 1832920 : PyObject *in_obj = NULL;
427 1832920 : PyObject *ret = NULL;
428 :
429 1832920 : mem_ctx_obj = pytalloc_GenericObject_reference(mem_ctx);
430 1832920 : if (mem_ctx_obj == NULL) {
431 0 : return NULL;
432 : }
433 :
434 1832920 : in_obj = pytalloc_GenericObject_reference_ex(mem_ctx, discard_const(in));
435 1832920 : if (in_obj == NULL) {
436 0 : Py_XDECREF(mem_ctx_obj);
437 0 : return NULL;
438 : }
439 :
440 1832920 : ret = PyObject_CallMethod((PyObject *)type,
441 : discard_const_p(char, "__import__"),
442 : discard_const_p(char, "OiO"),
443 : mem_ctx_obj, level, in_obj);
444 1832920 : Py_XDECREF(mem_ctx_obj);
445 1832920 : Py_XDECREF(in_obj);
446 1832920 : if (ret == NULL) {
447 0 : return NULL;
448 : }
449 :
450 1832920 : return ret;
451 : }
452 :
453 36075 : void *pyrpc_export_union(PyTypeObject *type, TALLOC_CTX *mem_ctx, int level,
454 : PyObject *in, const char *typename)
455 : {
456 36075 : PyObject *mem_ctx_obj = NULL;
457 36075 : PyObject *ret_obj = NULL;
458 36075 : void *ret = NULL;
459 :
460 36075 : mem_ctx_obj = pytalloc_GenericObject_reference(mem_ctx);
461 36075 : if (mem_ctx_obj == NULL) {
462 0 : return NULL;
463 : }
464 :
465 36075 : ret_obj = PyObject_CallMethod((PyObject *)type,
466 : discard_const_p(char, "__export__"),
467 : discard_const_p(char, "OiO"),
468 : mem_ctx_obj, level, in);
469 36075 : Py_XDECREF(mem_ctx_obj);
470 36075 : if (ret_obj == NULL) {
471 0 : return NULL;
472 : }
473 :
474 36075 : ret = _pytalloc_get_type(ret_obj, typename);
475 36075 : Py_XDECREF(ret_obj);
476 33554 : return ret;
477 : }
478 :
479 30 : PyObject *py_dcerpc_ndr_pointer_deref(PyTypeObject *type, PyObject *obj)
480 : {
481 30 : if (!PyObject_TypeCheck(obj, type)) {
482 0 : PyErr_Format(PyExc_TypeError,
483 : "Expected type '%s' but got type '%s'",
484 0 : (type)->tp_name, Py_TYPE(obj)->tp_name);
485 0 : return NULL;
486 : }
487 :
488 30 : return PyObject_GetAttrString(obj, discard_const_p(char, "value"));
489 : }
490 :
491 298 : PyObject *py_dcerpc_ndr_pointer_wrap(PyTypeObject *type, PyObject *obj)
492 : {
493 298 : PyObject *args = NULL;
494 298 : PyObject *ret_obj = NULL;
495 :
496 298 : args = PyTuple_New(1);
497 298 : if (args == NULL) {
498 0 : return NULL;
499 : }
500 298 : Py_XINCREF(obj);
501 298 : PyTuple_SetItem(args, 0, obj);
502 :
503 298 : ret_obj = PyObject_Call((PyObject *)type, args, NULL);
504 298 : Py_XDECREF(args);
505 298 : return ret_obj;
506 : }
|
