source: trunk/server/source4/librpc/rpc/pyrpc_util.c

Last change on this file was 745, checked in by Silvan Scherrer, 13 years ago

Samba Server: updated trunk to 3.6.0
File size: 8.5 KB
Line 
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
34bool 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 */
69static 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 messaging_context *msg;
76
77 msg = messaging_client_init(mem_ctx, lpcfg_messaging_path(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
89PyObject *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(lp_ctx);
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
190static 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
234static 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
242bool 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
263void 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 */
281PyObject *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 py_talloc_reference_ex(py_type, r_ctx, r);
302}
303
304PyObject *PyString_FromStringOrNULL(const char *str)
305{
306 if (str == NULL) {
307 Py_RETURN_NONE;
308 }
309 return PyString_FromString(str);
310}
Note: See TracBrowser for help on using the repository browser.