2 Unix SMB/CIFS implementation.
3 Samba utility functions
4 Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008
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/>.
22 #include <structmember.h>
23 #include "librpc/rpc/pyrpc.h"
24 #include "lib/events/events.h"
25 #include "param/pyparam.h"
26 #include "librpc/rpc/dcerpc.h"
27 #include "librpc/rpc/pyrpc_util.h"
28 #include "auth/credentials/pycredentials.h"
32 staticforward PyTypeObject dcerpc_InterfaceType
;
34 static bool PyString_AsGUID(PyObject
*object
, struct GUID
*uuid
)
37 status
= GUID_from_string(PyString_AsString(object
), uuid
);
38 if (NT_STATUS_IS_ERR(status
)) {
39 PyErr_SetNTSTATUS(status
);
45 static bool ndr_syntax_from_py_object(PyObject
*object
, struct ndr_syntax_id
*syntax_id
)
47 ZERO_STRUCTP(syntax_id
);
49 if (PyString_Check(object
)) {
50 return PyString_AsGUID(object
, &syntax_id
->uuid
);
51 } else if (PyTuple_Check(object
)) {
52 if (PyTuple_Size(object
) < 1 || PyTuple_Size(object
) > 2) {
53 PyErr_SetString(PyExc_ValueError
, "Syntax ID tuple has invalid size");
57 if (!PyString_Check(PyTuple_GetItem(object
, 0))) {
58 PyErr_SetString(PyExc_ValueError
, "Expected GUID as first element in tuple");
62 if (!PyString_AsGUID(PyTuple_GetItem(object
, 0), &syntax_id
->uuid
))
65 if (!PyInt_Check(PyTuple_GetItem(object
, 1))) {
66 PyErr_SetString(PyExc_ValueError
, "Expected version as second element in tuple");
70 syntax_id
->if_version
= PyInt_AsLong(PyTuple_GetItem(object
, 1));
74 PyErr_SetString(PyExc_TypeError
, "Expected UUID or syntax id tuple");
78 static PyObject
*py_iface_server_name(PyObject
*obj
, void *closure
)
80 const char *server_name
;
81 dcerpc_InterfaceObject
*iface
= (dcerpc_InterfaceObject
*)obj
;
83 server_name
= dcerpc_server_name(iface
->pipe
);
84 if (server_name
== NULL
)
87 return PyString_FromString(server_name
);
90 static PyObject
*py_ndr_syntax_id(struct ndr_syntax_id
*syntax_id
)
95 uuid_str
= GUID_string(NULL
, &syntax_id
->uuid
);
99 ret
= Py_BuildValue("(s,i)", uuid_str
, syntax_id
->if_version
);
101 talloc_free(uuid_str
);
106 static PyObject
*py_iface_abstract_syntax(PyObject
*obj
, void *closure
)
108 dcerpc_InterfaceObject
*iface
= (dcerpc_InterfaceObject
*)obj
;
110 return py_ndr_syntax_id(&iface
->pipe
->syntax
);
113 static PyObject
*py_iface_transfer_syntax(PyObject
*obj
, void *closure
)
115 dcerpc_InterfaceObject
*iface
= (dcerpc_InterfaceObject
*)obj
;
117 return py_ndr_syntax_id(&iface
->pipe
->transfer_syntax
);
120 static PyObject
*py_iface_session_key(PyObject
*obj
, void *closure
)
122 dcerpc_InterfaceObject
*iface
= (dcerpc_InterfaceObject
*)obj
;
123 DATA_BLOB session_key
;
125 NTSTATUS status
= dcerpc_fetch_session_key(iface
->pipe
, &session_key
);
126 PyErr_NTSTATUS_IS_ERR_RAISE(status
);
128 return PyString_FromStringAndSize((const char *)session_key
.data
, session_key
.length
);
131 static PyGetSetDef dcerpc_interface_getsetters
[] = {
132 { discard_const_p(char, "server_name"), py_iface_server_name
, NULL
,
133 discard_const_p(char, "name of the server, if connected over SMB") },
134 { discard_const_p(char, "abstract_syntax"), py_iface_abstract_syntax
, NULL
,
135 discard_const_p(char, "syntax id of the abstract syntax") },
136 { discard_const_p(char, "transfer_syntax"), py_iface_transfer_syntax
, NULL
,
137 discard_const_p(char, "syntax id of the transfersyntax") },
138 { discard_const_p(char, "session_key"), py_iface_session_key
, NULL
,
139 discard_const_p(char, "session key (as used for blob encryption on LSA and SAMR)") },
143 static PyMemberDef dcerpc_interface_members
[] = {
144 { discard_const_p(char, "request_timeout"), T_INT
,
145 offsetof(struct dcerpc_pipe
, request_timeout
), 0,
146 discard_const_p(char, "request timeout, in seconds") },
150 static PyObject
*py_iface_request(PyObject
*self
, PyObject
*args
, PyObject
*kwargs
)
152 dcerpc_InterfaceObject
*iface
= (dcerpc_InterfaceObject
*)self
;
154 DATA_BLOB data_in
, data_out
;
159 PyObject
*object
= NULL
;
160 struct GUID object_guid
;
161 TALLOC_CTX
*mem_ctx
= talloc_new(NULL
);
162 uint32_t out_flags
= 0;
163 const char *kwnames
[] = { "opnum", "data", "object", NULL
};
165 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "is#|O:request",
166 discard_const_p(char *, kwnames
), &opnum
, &in_data
, &in_length
, &object
)) {
167 talloc_free(mem_ctx
);
171 data_in
.data
= (uint8_t *)talloc_memdup(mem_ctx
, in_data
, in_length
);
172 data_in
.length
= in_length
;
174 ZERO_STRUCT(data_out
);
176 if (object
!= NULL
&& !PyString_AsGUID(object
, &object_guid
)) {
177 talloc_free(mem_ctx
);
181 status
= dcerpc_binding_handle_raw_call(iface
->binding_handle
,
182 object
?&object_guid
:NULL
,
191 if (!NT_STATUS_IS_OK(status
)) {
192 PyErr_SetDCERPCStatus(iface
->pipe
, status
);
193 talloc_free(mem_ctx
);
197 ret
= PyString_FromStringAndSize((char *)data_out
.data
, data_out
.length
);
199 talloc_free(mem_ctx
);
203 static PyObject
*py_iface_alter_context(PyObject
*self
, PyObject
*args
, PyObject
*kwargs
)
205 dcerpc_InterfaceObject
*iface
= (dcerpc_InterfaceObject
*)self
;
207 const char *kwnames
[] = { "abstract_syntax", "transfer_syntax", NULL
};
208 PyObject
*py_abstract_syntax
= Py_None
, *py_transfer_syntax
= Py_None
;
209 struct ndr_syntax_id abstract_syntax
, transfer_syntax
;
211 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "O|O:alter_context",
212 discard_const_p(char *, kwnames
), &py_abstract_syntax
,
213 &py_transfer_syntax
)) {
217 if (!ndr_syntax_from_py_object(py_abstract_syntax
, &abstract_syntax
))
220 if (py_transfer_syntax
== Py_None
) {
221 transfer_syntax
= ndr_transfer_syntax
;
223 if (!ndr_syntax_from_py_object(py_transfer_syntax
,
228 status
= dcerpc_alter_context(iface
->pipe
, iface
->pipe
, &abstract_syntax
,
231 if (!NT_STATUS_IS_OK(status
)) {
232 PyErr_SetDCERPCStatus(iface
->pipe
, status
);
239 static PyMethodDef dcerpc_interface_methods
[] = {
240 { "request", (PyCFunction
)py_iface_request
, METH_VARARGS
|METH_KEYWORDS
, "S.request(opnum, data, object=None) -> data\nMake a raw request" },
241 { "alter_context", (PyCFunction
)py_iface_alter_context
, METH_VARARGS
|METH_KEYWORDS
, "S.alter_context(syntax)\nChange to a different interface" },
242 { NULL
, NULL
, 0, NULL
},
245 static void dcerpc_interface_dealloc(PyObject
* self
)
247 dcerpc_InterfaceObject
*interface
= (dcerpc_InterfaceObject
*)self
;
248 talloc_free(interface
->mem_ctx
);
249 self
->ob_type
->tp_free(self
);
252 static PyObject
*dcerpc_interface_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kwargs
)
254 dcerpc_InterfaceObject
*ret
;
255 const char *binding_string
;
256 struct cli_credentials
*credentials
;
257 struct loadparm_context
*lp_ctx
= NULL
;
258 PyObject
*py_lp_ctx
= Py_None
, *py_credentials
= Py_None
;
260 struct tevent_context
*event_ctx
;
263 PyObject
*syntax
, *py_basis
= Py_None
;
264 const char *kwnames
[] = {
265 "binding", "syntax", "lp_ctx", "credentials", "basis_connection", NULL
267 struct ndr_interface_table
*table
;
269 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "sO|OOO:connect", discard_const_p(char *, kwnames
), &binding_string
, &syntax
, &py_lp_ctx
, &py_credentials
, &py_basis
)) {
273 mem_ctx
= talloc_new(NULL
);
274 if (mem_ctx
== NULL
) {
279 lp_ctx
= lpcfg_from_py_object(mem_ctx
, py_lp_ctx
);
280 if (lp_ctx
== NULL
) {
281 PyErr_SetString(PyExc_TypeError
, "Expected loadparm context");
282 talloc_free(mem_ctx
);
286 credentials
= cli_credentials_from_py_object(py_credentials
);
287 if (credentials
== NULL
) {
288 PyErr_SetString(PyExc_TypeError
, "Expected credentials");
289 talloc_free(mem_ctx
);
292 ret
= PyObject_New(dcerpc_InterfaceObject
, type
);
293 ret
->mem_ctx
= mem_ctx
;
295 event_ctx
= s4_event_context_init(ret
->mem_ctx
);
297 /* Create a dummy interface table struct. TODO: In the future, we should
298 * rather just allow connecting without requiring an interface table.
301 table
= talloc_zero(ret
->mem_ctx
, struct ndr_interface_table
);
304 PyErr_SetString(PyExc_MemoryError
, "Allocating interface table");
305 talloc_free(mem_ctx
);
309 if (!ndr_syntax_from_py_object(syntax
, &table
->syntax_id
)) {
310 talloc_free(mem_ctx
);
315 ret
->binding_handle
= NULL
;
317 if (py_basis
!= Py_None
) {
318 struct dcerpc_pipe
*base_pipe
;
320 if (!PyObject_TypeCheck(py_basis
, &dcerpc_InterfaceType
)) {
321 PyErr_SetString(PyExc_ValueError
, "basis_connection must be a DCE/RPC connection");
322 talloc_free(mem_ctx
);
326 base_pipe
= talloc_reference(ret
->mem_ctx
,
327 ((dcerpc_InterfaceObject
*)py_basis
)->pipe
);
329 status
= dcerpc_secondary_context(base_pipe
, &ret
->pipe
, table
);
331 ret
->pipe
= talloc_steal(ret
->mem_ctx
, ret
->pipe
);
333 status
= dcerpc_pipe_connect(ret
->mem_ctx
, &ret
->pipe
, binding_string
,
334 table
, credentials
, event_ctx
, lp_ctx
);
337 if (!NT_STATUS_IS_OK(status
)) {
338 PyErr_SetDCERPCStatus(ret
->pipe
, status
);
339 talloc_free(ret
->mem_ctx
);
342 ret
->pipe
->conn
->flags
|= DCERPC_NDR_REF_ALLOC
;
343 ret
->binding_handle
= ret
->pipe
->binding_handle
;
344 return (PyObject
*)ret
;
347 static PyTypeObject dcerpc_InterfaceType
= {
348 PyObject_HEAD_INIT(NULL
) 0,
349 .tp_name
= "dcerpc.ClientConnection",
350 .tp_basicsize
= sizeof(dcerpc_InterfaceObject
),
351 .tp_dealloc
= dcerpc_interface_dealloc
,
352 .tp_getset
= dcerpc_interface_getsetters
,
353 .tp_members
= dcerpc_interface_members
,
354 .tp_methods
= dcerpc_interface_methods
,
355 .tp_doc
= "ClientConnection(binding, syntax, lp_ctx=None, credentials=None) -> connection\n"
357 "binding should be a DCE/RPC binding string (for example: ncacn_ip_tcp:127.0.0.1)\n"
358 "syntax should be a tuple with a GUID and version number of an interface\n"
359 "lp_ctx should be a path to a smb.conf file or a param.LoadParm object\n"
360 "credentials should be a credentials.Credentials object.\n\n",
361 .tp_flags
= Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
,
362 .tp_new
= dcerpc_interface_new
,
369 if (PyType_Ready(&dcerpc_InterfaceType
) < 0)
372 m
= Py_InitModule3("base", NULL
, "DCE/RPC protocol implementation");
376 Py_INCREF((PyObject
*)&dcerpc_InterfaceType
);
377 PyModule_AddObject(m
, "ClientConnection", (PyObject
*)&dcerpc_InterfaceType
);