s4-messaging: Pass the loadparm context, not just the messaging path
[gd/samba-autobuild/.git] / source4 / librpc / rpc / pyrpc_util.c
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 "includes.h"
25 #include "librpc/rpc/pyrpc_util.h"
26 #include "librpc/rpc/dcerpc.h"
27 #include "librpc/rpc/pyrpc.h"
28 #include "param/pyparam.h"
29 #include "auth/credentials/pycredentials.h"
30 #include "lib/events/events.h"
31 #include "lib/messaging/messaging.h"
32 #include "lib/messaging/irpc.h"
33
34 bool py_check_dcerpc_type(PyObject *obj, const char *module, const char *type_name)
35 {
36         PyObject *mod;
37         PyTypeObject *type;
38         bool ret;
39
40         mod = PyImport_ImportModule(module);
41
42         if (mod == NULL) {
43                 PyErr_Format(PyExc_RuntimeError, "Unable to import %s to check type %s",
44                         module, type_name);
45                 return NULL;
46         }
47
48         type = (PyTypeObject *)PyObject_GetAttrString(mod, type_name);
49         Py_DECREF(mod);
50         if (type == NULL) {
51                 PyErr_Format(PyExc_RuntimeError, "Unable to find type %s in module %s",
52                         module, type_name);
53                 return NULL;
54         }
55
56         ret = PyObject_TypeCheck(obj, type);
57         Py_DECREF(type);
58
59         if (!ret)
60                 PyErr_Format(PyExc_TypeError, "Expected type %s.%s, got %s",
61                         module, type_name, Py_TYPE(obj)->tp_name);
62
63         return ret;
64 }
65
66 /*
67   connect to a IRPC pipe from python
68  */
69 static NTSTATUS pyrpc_irpc_connect(TALLOC_CTX *mem_ctx, const char *irpc_server,
70                                    const struct ndr_interface_table *table,
71                                    struct tevent_context *event_ctx,
72                                    struct loadparm_context *lp_ctx,
73                                    struct dcerpc_binding_handle **binding_handle)
74 {
75         struct imessaging_context *msg;
76
77         msg = imessaging_client_init(mem_ctx, lp_ctx, event_ctx);
78         NT_STATUS_HAVE_NO_MEMORY(msg);
79
80         *binding_handle = irpc_binding_handle_by_name(mem_ctx, msg, irpc_server, table);
81         if (*binding_handle == NULL) {
82                 talloc_free(msg);
83                 return NT_STATUS_INVALID_PIPE_STATE;
84         }
85
86         return NT_STATUS_OK;
87 }
88
89 PyObject *py_dcerpc_interface_init_helper(PyTypeObject *type, PyObject *args, PyObject *kwargs,
90                                           const struct ndr_interface_table *table)
91 {
92         dcerpc_InterfaceObject *ret;
93         const char *binding_string;
94         struct cli_credentials *credentials;
95         struct loadparm_context *lp_ctx = NULL;
96         PyObject *py_lp_ctx = Py_None, *py_credentials = Py_None, *py_basis = Py_None;
97         TALLOC_CTX *mem_ctx = NULL;
98         struct tevent_context *event_ctx;
99         NTSTATUS status;
100
101         const char *kwnames[] = {
102                 "binding", "lp_ctx", "credentials", "basis_connection", NULL
103         };
104
105         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|OOO:samr", discard_const_p(char *, kwnames), &binding_string, &py_lp_ctx, &py_credentials, &py_basis)) {
106                 return NULL;
107         }
108
109         mem_ctx = talloc_new(NULL);
110         if (mem_ctx == NULL) {
111                 PyErr_NoMemory();
112                 return NULL;
113         }
114
115         lp_ctx = lpcfg_from_py_object(mem_ctx, py_lp_ctx);
116         if (lp_ctx == NULL) {
117                 PyErr_SetString(PyExc_TypeError, "Expected loadparm context");
118                 talloc_free(mem_ctx);
119                 return NULL;
120         }
121
122         status = dcerpc_init();
123         if (!NT_STATUS_IS_OK(status)) {
124                 PyErr_SetNTSTATUS(status);
125                 talloc_free(mem_ctx);
126                 return NULL;
127         }
128
129         ret = PyObject_New(dcerpc_InterfaceObject, type);
130         ret->mem_ctx = mem_ctx;
131
132         event_ctx = s4_event_context_init(ret->mem_ctx);
133
134         if (strncmp(binding_string, "irpc:", 5) == 0) {
135                 ret->pipe = NULL;
136                 status = pyrpc_irpc_connect(ret->mem_ctx, binding_string+5, table,
137                                             event_ctx, lp_ctx, &ret->binding_handle);
138         } else if (py_basis != Py_None) {
139                 struct dcerpc_pipe *base_pipe;
140                 PyObject *py_base;
141                 PyTypeObject *ClientConnection_Type;
142
143                 py_base = PyImport_ImportModule("samba.dcerpc.base");
144                 if (py_base == NULL) {
145                         talloc_free(mem_ctx);
146                         return NULL;
147                 }
148
149                 ClientConnection_Type = (PyTypeObject *)PyObject_GetAttrString(py_base, "ClientConnection");
150                 if (ClientConnection_Type == NULL) {
151                         PyErr_SetNone(PyExc_TypeError);
152                         talloc_free(mem_ctx);
153                         return NULL;
154                 }
155
156                 if (!PyObject_TypeCheck(py_basis, ClientConnection_Type)) {
157                         PyErr_SetString(PyExc_TypeError, "basis_connection must be a DCE/RPC connection");
158                         talloc_free(mem_ctx);
159                         return NULL;
160                 }
161
162                 base_pipe = talloc_reference(mem_ctx, ((dcerpc_InterfaceObject *)py_basis)->pipe);
163
164                 status = dcerpc_secondary_context(base_pipe, &ret->pipe, table);
165
166                 ret->pipe = talloc_steal(ret->mem_ctx, ret->pipe);
167         } else {
168                 credentials = cli_credentials_from_py_object(py_credentials);
169                 if (credentials == NULL) {
170                         PyErr_SetString(PyExc_TypeError, "Expected credentials");
171                         talloc_free(mem_ctx);
172                         return NULL;
173                 }
174                 status = dcerpc_pipe_connect(event_ctx, &ret->pipe, binding_string,
175                              table, credentials, event_ctx, lp_ctx);
176         }
177         if (NT_STATUS_IS_ERR(status)) {
178                 PyErr_SetNTSTATUS(status);
179                 talloc_free(mem_ctx);
180                 return NULL;
181         }
182
183         if (ret->pipe) {
184                 ret->pipe->conn->flags |= DCERPC_NDR_REF_ALLOC;
185                 ret->binding_handle = ret->pipe->binding_handle;
186         }
187         return (PyObject *)ret;
188 }
189
190 static PyObject *py_dcerpc_run_function(dcerpc_InterfaceObject *iface,
191                                         const struct PyNdrRpcMethodDef *md,
192                                         PyObject *args, PyObject *kwargs)
193 {
194         TALLOC_CTX *mem_ctx;
195         NTSTATUS status;
196         void *r;
197         PyObject *result = Py_None;
198
199         if (md->pack_in_data == NULL || md->unpack_out_data == NULL) {
200                 PyErr_SetString(PyExc_NotImplementedError, "No marshalling code available yet");
201                 return NULL;
202         }
203
204         mem_ctx = talloc_new(NULL);
205         if (mem_ctx == NULL) {
206                 PyErr_NoMemory();
207                 return NULL;
208         }
209
210         r = talloc_zero_size(mem_ctx, md->table->calls[md->opnum].struct_size);
211         if (r == NULL) {
212                 PyErr_NoMemory();
213                 return NULL;
214         }
215
216         if (!md->pack_in_data(args, kwargs, r)) {
217                 talloc_free(mem_ctx);
218                 return NULL;
219         }
220
221         status = md->call(iface->binding_handle, mem_ctx, r);
222         if (!NT_STATUS_IS_OK(status)) {
223                 PyErr_SetDCERPCStatus(iface->pipe, status);
224                 talloc_free(mem_ctx);
225                 return NULL;
226         }
227
228         result = md->unpack_out_data(r);
229
230         talloc_free(mem_ctx);
231         return result;
232 }
233
234 static PyObject *py_dcerpc_call_wrapper(PyObject *self, PyObject *args, void *wrapped, PyObject *kwargs)
235 {       
236         dcerpc_InterfaceObject *iface = (dcerpc_InterfaceObject *)self;
237         const struct PyNdrRpcMethodDef *md = (const struct PyNdrRpcMethodDef *)wrapped;
238
239         return py_dcerpc_run_function(iface, md, args, kwargs);
240 }
241
242 bool PyInterface_AddNdrRpcMethods(PyTypeObject *ifacetype, const struct PyNdrRpcMethodDef *mds)
243 {
244         int i;
245         for (i = 0; mds[i].name; i++) {
246                 PyObject *ret;
247                 struct wrapperbase *wb = (struct wrapperbase *)calloc(sizeof(struct wrapperbase), 1);
248
249                 wb->name = discard_const_p(char, mds[i].name);
250                 wb->flags = PyWrapperFlag_KEYWORDS;
251                 wb->wrapper = (wrapperfunc)py_dcerpc_call_wrapper;
252                 wb->doc = discard_const_p(char, mds[i].doc);
253
254                 ret = PyDescr_NewWrapper(ifacetype, wb, discard_const_p(void, &mds[i]));
255
256                 PyDict_SetItemString(ifacetype->tp_dict, mds[i].name, 
257                                      (PyObject *)ret);
258         }
259
260         return true;
261 }
262
263 void PyErr_SetDCERPCStatus(struct dcerpc_pipe *p, NTSTATUS status)
264 {
265         if (p && NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
266                 status = dcerpc_fault_to_nt_status(p->last_fault_code);
267         }
268         PyErr_SetNTSTATUS(status);
269 }
270
271
272 /*
273   take a NDR structure that has a type in a python module and return
274   it as a python object
275
276   r is the NDR structure pointer (a C structure)
277
278   r_ctx is the context that is a parent of r. It will be referenced by
279   the resulting python object
280  */
281 PyObject *py_return_ndr_struct(const char *module_name, const char *type_name,
282                                TALLOC_CTX *r_ctx, void *r)
283 {
284         PyTypeObject *py_type;
285         PyObject *module;
286
287         if (r == NULL) {
288                 Py_RETURN_NONE;
289         }
290
291         module = PyImport_ImportModule(module_name);
292         if (module == NULL) {
293                 return NULL;
294         }
295
296         py_type = (PyTypeObject *)PyObject_GetAttrString(module, type_name);
297         if (py_type == NULL) {
298                 return NULL;
299         }
300
301         return pytalloc_reference_ex(py_type, r_ctx, r);
302 }
303
304 PyObject *PyString_FromStringOrNULL(const char *str)
305 {
306         if (str == NULL) {
307                 Py_RETURN_NONE;
308         }
309         return PyString_FromString(str);
310 }