LCOV - code coverage report
Current view: top level - source4/librpc/rpc - pyrpc_util.c (source / functions) Hit Total Coverage
Test: coverage report for master 6248eab5 Lines: 174 252 69.0 %
Date: 2021-08-25 13:27:56 Functions: 15 15 100.0 %

          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    51672025 : 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    51672025 :         mod = PyImport_ImportModule(module);
      43             : 
      44    51672025 :         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    51672025 :         type = (PyTypeObject *)PyObject_GetAttrString(mod, type_name);
      51    51672025 :         Py_DECREF(mod);
      52    51672025 :         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    51672025 :         ret = PyObject_TypeCheck(obj, type);
      59    51672025 :         Py_DECREF(type);
      60             : 
      61    51672025 :         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    45421111 :         return ret;
      66             : }
      67             : 
      68             : /*
      69             :   connect to a IRPC pipe from python
      70             :  */
      71           8 : 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           8 :         msg = imessaging_client_init(mem_ctx, lp_ctx, event_ctx);
      80           8 :         NT_STATUS_HAVE_NO_MEMORY(msg);
      81             : 
      82           8 :         *binding_handle = irpc_binding_handle_by_name(mem_ctx, msg, irpc_server, table);
      83           8 :         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           7 :         dcerpc_binding_handle_set_sync_ev(*binding_handle, event_ctx);
      93             : 
      94           7 :         return NT_STATUS_OK;
      95             : }
      96             : 
      97        3802 : 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        3802 :         PyObject *py_lp_ctx = Py_None, *py_credentials = Py_None, *py_basis = Py_None;
     103             :         NTSTATUS status;
     104        3802 :         unsigned int timeout = (unsigned int)-1;
     105        3802 :         const char *kwnames[] = {
     106             :                 "binding", "lp_ctx", "credentials", "timeout", "basis_connection", NULL
     107             :         };
     108             : 
     109        3802 :         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        3802 :         status = dcerpc_init();
     114        3802 :         if (!NT_STATUS_IS_OK(status)) {
     115           0 :                 PyErr_SetNTSTATUS(status);
     116           0 :                 return NULL;
     117             :         }
     118             : 
     119        3802 :         ret = PyObject_New(dcerpc_InterfaceObject, type);
     120        3802 :         if (ret == NULL) {
     121           0 :                 PyErr_NoMemory();
     122           0 :                 return NULL;
     123             :         }
     124             : 
     125        3802 :         ret->pipe = NULL;
     126        3802 :         ret->binding_handle = NULL;
     127        3802 :         ret->ev = NULL;
     128        3802 :         ret->mem_ctx = talloc_new(NULL);
     129        3802 :         if (ret->mem_ctx == NULL) {
     130           0 :                 PyErr_NoMemory();
     131           0 :                 return NULL;
     132             :         }
     133             : 
     134        3802 :         if (strncmp(binding_string, "irpc:", 5) == 0) {
     135             :                 struct loadparm_context *lp_ctx;
     136             : 
     137           8 :                 ret->ev = s4_event_context_init(ret->mem_ctx);
     138           8 :                 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           8 :                 lp_ctx = lpcfg_from_py_object(ret->ev, py_lp_ctx);
     146           8 :                 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           8 :                 status = pyrpc_irpc_connect(ret->mem_ctx, binding_string+5, table,
     153             :                                             ret->ev, lp_ctx, &ret->binding_handle);
     154           8 :                 if (!NT_STATUS_IS_OK(status)) {
     155           1 :                         PyErr_SetNTSTATUS(status);
     156           1 :                         Py_DECREF(ret);
     157           1 :                         return NULL;
     158             :                 }
     159        3794 :         } 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        3791 :                 ret->ev = s4_event_context_init(ret->mem_ctx);
     224        3791 :                 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        3791 :                 lp_ctx = lpcfg_from_py_object(ret->ev, py_lp_ctx);
     231        3791 :                 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        3791 :                 credentials = cli_credentials_from_py_object(py_credentials);
     238        3791 :                 if (credentials == NULL) {
     239           0 :                         PyErr_SetString(PyExc_TypeError, "Expected credentials");
     240           0 :                         Py_DECREF(ret);
     241           0 :                         return NULL;
     242             :                 }
     243        3791 :                 status = dcerpc_pipe_connect(ret->mem_ctx, &ret->pipe, binding_string,
     244             :                              table, credentials, ret->ev, lp_ctx);
     245        3791 :                 if (!NT_STATUS_IS_OK(status)) {
     246          19 :                         PyErr_SetNTSTATUS(status);
     247          19 :                         Py_DECREF(ret);
     248          19 :                         return NULL;
     249             :                 }
     250             :         }
     251             : 
     252        3782 :         if (ret->pipe) {
     253        3775 :                 ret->pipe->conn->flags |= DCERPC_NDR_REF_ALLOC;
     254        3775 :                 ret->binding_handle = ret->pipe->binding_handle;
     255             :         }
     256             : 
     257             :         /* reset timeout for the handle */
     258        3782 :         if ((timeout != ((unsigned int)-1)) && (ret->binding_handle != NULL)) {
     259           0 :                 dcerpc_binding_handle_set_timeout(ret->binding_handle, timeout);
     260             :         }
     261             : 
     262        3778 :         return (PyObject *)ret;
     263             : }
     264             : 
     265       18064 : 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       18064 :         PyObject *result = Py_None;
     273             : 
     274       18064 :         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       18064 :         mem_ctx = talloc_new(NULL);
     280       18064 :         if (mem_ctx == NULL) {
     281           0 :                 PyErr_NoMemory();
     282           0 :                 return NULL;
     283             :         }
     284             : 
     285       18064 :         r = talloc_zero_size(mem_ctx, md->table->calls[md->opnum].struct_size);
     286       18064 :         if (r == NULL) {
     287           0 :                 PyErr_NoMemory();
     288           0 :                 return NULL;
     289             :         }
     290             : 
     291       18064 :         if (!md->pack_in_data(args, kwargs, r)) {
     292           0 :                 talloc_free(mem_ctx);
     293           0 :                 return NULL;
     294             :         }
     295             : 
     296       18064 :         status = md->call(iface->binding_handle, mem_ctx, r);
     297       18064 :         if (!NT_STATUS_IS_OK(status)) {
     298          88 :                 PyErr_SetDCERPCStatus(iface->pipe, status);
     299          88 :                 talloc_free(mem_ctx);
     300          88 :                 return NULL;
     301             :         }
     302             : 
     303       17976 :         result = md->unpack_out_data(r);
     304             : 
     305       17976 :         talloc_free(mem_ctx);
     306       17966 :         return result;
     307             : }
     308             : 
     309       18064 : static PyObject *py_dcerpc_call_wrapper(PyObject *self, PyObject *args, void *wrapped, PyObject *kwargs)
     310             : {       
     311       18064 :         dcerpc_InterfaceObject *iface = (dcerpc_InterfaceObject *)self;
     312       18064 :         const struct PyNdrRpcMethodDef *md = (const struct PyNdrRpcMethodDef *)wrapped;
     313             : 
     314       18064 :         return py_dcerpc_run_function(iface, md, args, kwargs);
     315             : }
     316             : 
     317       38591 : bool PyInterface_AddNdrRpcMethods(PyTypeObject *ifacetype, const struct PyNdrRpcMethodDef *mds)
     318             : {
     319             :         int i;
     320      935032 :         for (i = 0; mds[i].name; i++) {
     321             :                 PyObject *ret;
     322      896441 :                 struct wrapperbase *wb = (struct wrapperbase *)calloc(sizeof(struct wrapperbase), 1);
     323             : 
     324      896441 :                 if (wb == NULL) {
     325           0 :                         return false;
     326             :                 }
     327      896441 :                 wb->name = discard_const_p(char, mds[i].name);
     328      896441 :                 wb->flags = PyWrapperFlag_KEYWORDS;
     329      896441 :                 wb->wrapper = PY_DISCARD_FUNC_SIG(wrapperfunc,
     330             :                                                   py_dcerpc_call_wrapper);
     331      896441 :                 wb->doc = discard_const_p(char, mds[i].doc);
     332             : 
     333      896441 :                 ret = PyDescr_NewWrapper(ifacetype, wb, discard_const_p(void, &mds[i]));
     334             : 
     335      896441 :                 PyDict_SetItemString(ifacetype->tp_dict, mds[i].name, 
     336             :                                      (PyObject *)ret);
     337      896441 :                 Py_CLEAR(ret);
     338             :         }
     339             : 
     340       37290 :         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          88 : void PyErr_SetDCERPCStatus(struct dcerpc_pipe *p, NTSTATUS status)
     366             : {
     367          88 :         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          88 :         PyErr_SetNTSTATUS(status);
     371          88 : }
     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       33002 : 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       33002 :         PyObject *result = NULL;
     392             : 
     393       33002 :         if (r == NULL) {
     394           2 :                 Py_RETURN_NONE;
     395             :         }
     396             : 
     397       33000 :         module = PyImport_ImportModule(module_name);
     398       33000 :         if (module == NULL) {
     399           0 :                 return NULL;
     400             :         }
     401             : 
     402       33000 :         py_type = (PyTypeObject *)PyObject_GetAttrString(module, type_name);
     403       33000 :         if (py_type == NULL) {
     404           0 :                 Py_DECREF(module);
     405           0 :                 return NULL;
     406             :         }
     407             : 
     408       33000 :         result = pytalloc_reference_ex(py_type, r_ctx, r);
     409       33000 :         Py_CLEAR(module);
     410       33000 :         Py_CLEAR(py_type);
     411       32412 :         return result;
     412             : }
     413             : 
     414      173163 : PyObject *PyString_FromStringOrNULL(const char *str)
     415             : {
     416      173163 :         if (str == NULL) {
     417          87 :                 Py_RETURN_NONE;
     418             :         }
     419      173076 :         return PyUnicode_FromString(str);
     420             : }
     421             : 
     422     1854050 : PyObject *pyrpc_import_union(PyTypeObject *type, TALLOC_CTX *mem_ctx, int level,
     423             :                              const void *in, const char *typename)
     424             : {
     425     1854050 :         PyObject *mem_ctx_obj = NULL;
     426     1854050 :         PyObject *in_obj = NULL;
     427     1854050 :         PyObject *ret = NULL;
     428             : 
     429     1854050 :         mem_ctx_obj = pytalloc_GenericObject_reference(mem_ctx);
     430     1854050 :         if (mem_ctx_obj == NULL) {
     431           0 :                 return NULL;
     432             :         }
     433             : 
     434     1854050 :         in_obj = pytalloc_GenericObject_reference_ex(mem_ctx, discard_const(in));
     435     1854050 :         if (in_obj == NULL) {
     436           0 :                 Py_XDECREF(mem_ctx_obj);
     437           0 :                 return NULL;
     438             :         }
     439             : 
     440     1854050 :         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     1854050 :         Py_XDECREF(mem_ctx_obj);
     445     1854050 :         Py_XDECREF(in_obj);
     446     1854050 :         if (ret == NULL) {
     447           0 :                 return NULL;
     448             :         }
     449             : 
     450     1854050 :         return ret;
     451             : }
     452             : 
     453       41691 : void *pyrpc_export_union(PyTypeObject *type, TALLOC_CTX *mem_ctx, int level,
     454             :                          PyObject *in, const char *typename)
     455             : {
     456       41691 :         PyObject *mem_ctx_obj = NULL;
     457       41691 :         PyObject *ret_obj = NULL;
     458       41691 :         void *ret = NULL;
     459             : 
     460       41691 :         mem_ctx_obj = pytalloc_GenericObject_reference(mem_ctx);
     461       41691 :         if (mem_ctx_obj == NULL) {
     462           0 :                 return NULL;
     463             :         }
     464             : 
     465       41691 :         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       41691 :         Py_XDECREF(mem_ctx_obj);
     470       41691 :         if (ret_obj == NULL) {
     471           0 :                 return NULL;
     472             :         }
     473             : 
     474       41691 :         ret = _pytalloc_get_type(ret_obj, typename);
     475       41691 :         Py_XDECREF(ret_obj);
     476       39170 :         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         295 : PyObject *py_dcerpc_ndr_pointer_wrap(PyTypeObject *type, PyObject *obj)
     492             : {
     493         295 :         PyObject *args = NULL;
     494         295 :         PyObject *ret_obj = NULL;
     495             : 
     496         295 :         args = PyTuple_New(1);
     497         295 :         if (args == NULL) {
     498           0 :                 return NULL;
     499             :         }
     500         295 :         Py_XINCREF(obj);
     501         295 :         PyTuple_SetItem(args, 0, obj);
     502             : 
     503         295 :         ret_obj = PyObject_Call((PyObject *)type, args, NULL);
     504         295 :         Py_XDECREF(args);
     505         295 :         return ret_obj;
     506             : }

Generated by: LCOV version 1.13