LCOV - code coverage report
Current view: top level - bin/default/librpc/gen_ndr - py_epmapper.c (source / functions) Hit Total Coverage
Test: coverage report for master 2b515b7d Lines: 609 3790 16.1 %
Date: 2024-02-28 12:06:22 Functions: 44 268 16.4 %

          Line data    Source code
       1             : 
       2             : /* Python wrapper functions auto-generated by pidl */
       3             : #define PY_SSIZE_T_CLEAN 1 /* We use Py_ssize_t for PyArg_ParseTupleAndKeywords */
       4             : #include "lib/replace/system/python.h"
       5             : #include "python/py3compat.h"
       6             : #include "includes.h"
       7             : #include "python/modules.h"
       8             : #include <pytalloc.h>
       9             : #include "librpc/rpc/pyrpc.h"
      10             : #include "librpc/rpc/pyrpc_util.h"
      11             : #include "bin/default/librpc/gen_ndr/ndr_epmapper.h"
      12             : #include "bin/default/librpc/gen_ndr/ndr_epmapper_c.h"
      13             : 
      14             : /*
      15             :  * Suppress compiler warnings if the generated code does not call these
      16             :  * functions
      17             :  */
      18             : #ifndef _MAYBE_UNUSED_
      19             : #ifdef __has_attribute
      20             : #if __has_attribute(unused)
      21             : #define _MAYBE_UNUSED_ __attribute__ ((unused))
      22             : #else
      23             : #define _MAYBE_UNUSED_
      24             : #endif
      25             : #endif
      26             : #endif
      27             : /*
      28             :  * These functions are here to ensure they can be optimized out by
      29             :  * the compiler based on the constant input values
      30             :  */
      31             : 
      32         432 : static inline unsigned long long ndr_sizeof2uintmax(size_t var_size)
      33             : {
      34         432 :         switch (var_size) {
      35           0 :         case 8:
      36           0 :                 return UINT64_MAX;
      37         288 :         case 4:
      38         288 :                 return UINT32_MAX;
      39         144 :         case 2:
      40         144 :                 return UINT16_MAX;
      41           0 :         case 1:
      42           0 :                 return UINT8_MAX;
      43             :         }
      44             : 
      45           0 :         return 0;
      46             : }
      47             : 
      48             : static inline _MAYBE_UNUSED_ long long ndr_sizeof2intmax(size_t var_size)
      49             : {
      50             :         switch (var_size) {
      51             :         case 8:
      52             :                 return INT64_MAX;
      53             :         case 4:
      54             :                 return INT32_MAX;
      55             :         case 2:
      56             :                 return INT16_MAX;
      57             :         case 1:
      58             :                 return INT8_MAX;
      59             :         }
      60             : 
      61             :         return 0;
      62             : }
      63             : 
      64             : #include "librpc/gen_ndr/misc.h"
      65             : static PyTypeObject epm_rhs_dnet_nsp_Type;
      66             : static PyTypeObject epm_rhs_osi_tp4_Type;
      67             : static PyTypeObject epm_rhs_osi_clns_Type;
      68             : static PyTypeObject epm_rhs_udp_Type;
      69             : static PyTypeObject epm_rhs_tcp_Type;
      70             : static PyTypeObject epm_rhs_ip_Type;
      71             : static PyTypeObject epm_rhs_ncadg_Type;
      72             : static PyTypeObject epm_rhs_ncacn_Type;
      73             : static PyTypeObject epm_rhs_uuid_Type;
      74             : static PyTypeObject epm_rhs_ipx_Type;
      75             : static PyTypeObject epm_rhs_smb_Type;
      76             : static PyTypeObject epm_rhs_named_pipe_Type;
      77             : static PyTypeObject epm_rhs_netbios_Type;
      78             : static PyTypeObject epm_rhs_netbeui_Type;
      79             : static PyTypeObject epm_rhs_spx_Type;
      80             : static PyTypeObject epm_rhs_nb_ipx_Type;
      81             : static PyTypeObject epm_rhs_http_Type;
      82             : static PyTypeObject epm_rhs_unix_ds_Type;
      83             : static PyTypeObject epm_rhs_null_Type;
      84             : static PyTypeObject epm_rhs_ncalrpc_Type;
      85             : static PyTypeObject epm_rhs_appletalk_Type;
      86             : static PyTypeObject epm_rhs_atalk_stream_Type;
      87             : static PyTypeObject epm_rhs_atalk_datagram_Type;
      88             : static PyTypeObject epm_rhs_vines_spp_Type;
      89             : static PyTypeObject epm_rhs_vines_ipc_Type;
      90             : static PyTypeObject epm_rhs_streettalk_Type;
      91             : static PyTypeObject epm_rhs_Type;
      92             : static PyTypeObject epm_lhs_Type;
      93             : static PyTypeObject epm_floor_Type;
      94             : static PyTypeObject epm_tower_Type;
      95             : static PyTypeObject epm_twr_t_Type;
      96             : static PyTypeObject epm_entry_t_Type;
      97             : static PyTypeObject rpc_if_id_t_Type;
      98             : static PyTypeObject epm_twr_p_t_Type;
      99             : static PyTypeObject epmapper_InterfaceType;
     100             : static PyTypeObject epm_Insert_Type;
     101             : static PyTypeObject epm_Delete_Type;
     102             : static PyTypeObject epm_Lookup_Type;
     103             : static PyTypeObject epm_Map_Type;
     104             : static PyTypeObject epm_LookupHandleFree_Type;
     105             : static PyTypeObject epm_InqObject_Type;
     106             : static PyTypeObject epm_MgmtDelete_Type;
     107             : 
     108             : static PyTypeObject *BaseObject_Type;
     109             : static PyTypeObject *GUID_Type;
     110             : static PyTypeObject *policy_handle_Type;
     111             : static PyTypeObject *ClientConnection_Type;
     112             : static PyTypeObject *ndr_syntax_id_Type;
     113             : 
     114           0 : static PyObject *py_epm_rhs_dnet_nsp_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     115             : {
     116           0 :         return pytalloc_new(struct epm_rhs_dnet_nsp, type);
     117             : }
     118             : 
     119             : 
     120             : static PyTypeObject epm_rhs_dnet_nsp_Type = {
     121             :         PyVarObject_HEAD_INIT(NULL, 0)
     122             :         .tp_name = "epmapper.epm_rhs_dnet_nsp",
     123             :         .tp_getset = NULL,
     124             :         .tp_methods = NULL,
     125             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     126             :         .tp_new = py_epm_rhs_dnet_nsp_new,
     127             : };
     128             : 
     129             : 
     130           0 : static PyObject *py_epm_rhs_osi_tp4_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     131             : {
     132           0 :         return pytalloc_new(struct epm_rhs_osi_tp4, type);
     133             : }
     134             : 
     135             : 
     136             : static PyTypeObject epm_rhs_osi_tp4_Type = {
     137             :         PyVarObject_HEAD_INIT(NULL, 0)
     138             :         .tp_name = "epmapper.epm_rhs_osi_tp4",
     139             :         .tp_getset = NULL,
     140             :         .tp_methods = NULL,
     141             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     142             :         .tp_new = py_epm_rhs_osi_tp4_new,
     143             : };
     144             : 
     145             : 
     146           0 : static PyObject *py_epm_rhs_osi_clns_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     147             : {
     148           0 :         return pytalloc_new(struct epm_rhs_osi_clns, type);
     149             : }
     150             : 
     151             : 
     152             : static PyTypeObject epm_rhs_osi_clns_Type = {
     153             :         PyVarObject_HEAD_INIT(NULL, 0)
     154             :         .tp_name = "epmapper.epm_rhs_osi_clns",
     155             :         .tp_getset = NULL,
     156             :         .tp_methods = NULL,
     157             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     158             :         .tp_new = py_epm_rhs_osi_clns_new,
     159             : };
     160             : 
     161             : 
     162           0 : static PyObject *py_epm_rhs_udp_get_port(PyObject *obj, void *closure)
     163             : {
     164           0 :         struct epm_rhs_udp *object = pytalloc_get_ptr(obj);
     165           0 :         PyObject *py_port;
     166           0 :         py_port = PyLong_FromLong((uint16_t)(object->port));
     167           0 :         return py_port;
     168             : }
     169             : 
     170           0 : static int py_epm_rhs_udp_set_port(PyObject *py_obj, PyObject *value, void *closure)
     171             : {
     172           0 :         struct epm_rhs_udp *object = pytalloc_get_ptr(py_obj);
     173           0 :         if (value == NULL) {
     174           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->port");
     175           0 :                 return -1;
     176             :         }
     177             :         {
     178           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->port));
     179           0 :                 if (PyLong_Check(value)) {
     180           0 :                         unsigned long long test_var;
     181           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
     182           0 :                         if (PyErr_Occurred() != NULL) {
     183           0 :                                 return -1;
     184             :                         }
     185           0 :                         if (test_var > uint_max) {
     186           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
     187             :                                   PyLong_Type.tp_name, uint_max, test_var);
     188           0 :                                 return -1;
     189             :                         }
     190           0 :                         object->port = test_var;
     191             :                 } else {
     192           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
     193             :                           PyLong_Type.tp_name);
     194           0 :                         return -1;
     195             :                 }
     196             :         }
     197           0 :         return 0;
     198             : }
     199             : 
     200             : static PyGetSetDef py_epm_rhs_udp_getsetters[] = {
     201             :         {
     202             :                 .name = discard_const_p(char, "port"),
     203             :                 .get = py_epm_rhs_udp_get_port,
     204             :                 .set = py_epm_rhs_udp_set_port,
     205             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
     206             :         },
     207             :         { .name = NULL }
     208             : };
     209             : 
     210           0 : static PyObject *py_epm_rhs_udp_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     211             : {
     212           0 :         return pytalloc_new(struct epm_rhs_udp, type);
     213             : }
     214             : 
     215             : 
     216             : static PyTypeObject epm_rhs_udp_Type = {
     217             :         PyVarObject_HEAD_INIT(NULL, 0)
     218             :         .tp_name = "epmapper.epm_rhs_udp",
     219             :         .tp_getset = py_epm_rhs_udp_getsetters,
     220             :         .tp_methods = NULL,
     221             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     222             :         .tp_new = py_epm_rhs_udp_new,
     223             : };
     224             : 
     225             : 
     226          16 : static PyObject *py_epm_rhs_tcp_get_port(PyObject *obj, void *closure)
     227             : {
     228          16 :         struct epm_rhs_tcp *object = pytalloc_get_ptr(obj);
     229           0 :         PyObject *py_port;
     230          16 :         py_port = PyLong_FromLong((uint16_t)(object->port));
     231          16 :         return py_port;
     232             : }
     233             : 
     234          48 : static int py_epm_rhs_tcp_set_port(PyObject *py_obj, PyObject *value, void *closure)
     235             : {
     236          48 :         struct epm_rhs_tcp *object = pytalloc_get_ptr(py_obj);
     237          48 :         if (value == NULL) {
     238           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->port");
     239           0 :                 return -1;
     240             :         }
     241             :         {
     242          48 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->port));
     243          48 :                 if (PyLong_Check(value)) {
     244           0 :                         unsigned long long test_var;
     245          48 :                         test_var = PyLong_AsUnsignedLongLong(value);
     246          48 :                         if (PyErr_Occurred() != NULL) {
     247           0 :                                 return -1;
     248             :                         }
     249          48 :                         if (test_var > uint_max) {
     250           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
     251             :                                   PyLong_Type.tp_name, uint_max, test_var);
     252           0 :                                 return -1;
     253             :                         }
     254          48 :                         object->port = test_var;
     255             :                 } else {
     256           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
     257             :                           PyLong_Type.tp_name);
     258           0 :                         return -1;
     259             :                 }
     260             :         }
     261          48 :         return 0;
     262             : }
     263             : 
     264             : static PyGetSetDef py_epm_rhs_tcp_getsetters[] = {
     265             :         {
     266             :                 .name = discard_const_p(char, "port"),
     267             :                 .get = py_epm_rhs_tcp_get_port,
     268             :                 .set = py_epm_rhs_tcp_set_port,
     269             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
     270             :         },
     271             :         { .name = NULL }
     272             : };
     273             : 
     274           0 : static PyObject *py_epm_rhs_tcp_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     275             : {
     276           0 :         return pytalloc_new(struct epm_rhs_tcp, type);
     277             : }
     278             : 
     279             : 
     280             : static PyTypeObject epm_rhs_tcp_Type = {
     281             :         PyVarObject_HEAD_INIT(NULL, 0)
     282             :         .tp_name = "epmapper.epm_rhs_tcp",
     283             :         .tp_getset = py_epm_rhs_tcp_getsetters,
     284             :         .tp_methods = NULL,
     285             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     286             :         .tp_new = py_epm_rhs_tcp_new,
     287             : };
     288             : 
     289             : 
     290           0 : static PyObject *py_epm_rhs_ip_get_ipaddr(PyObject *obj, void *closure)
     291             : {
     292           0 :         struct epm_rhs_ip *object = pytalloc_get_ptr(obj);
     293           0 :         PyObject *py_ipaddr;
     294           0 :         py_ipaddr = PyString_FromStringOrNULL(object->ipaddr);
     295           0 :         return py_ipaddr;
     296             : }
     297             : 
     298          48 : static int py_epm_rhs_ip_set_ipaddr(PyObject *py_obj, PyObject *value, void *closure)
     299             : {
     300          48 :         struct epm_rhs_ip *object = pytalloc_get_ptr(py_obj);
     301          48 :         if (value == NULL) {
     302           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->ipaddr");
     303           0 :                 return -1;
     304             :         }
     305             :         {
     306           0 :                 const char *test_str;
     307           0 :                 const char *talloc_str;
     308          48 :                 PyObject *unicode = NULL;
     309          48 :                 if (PyUnicode_Check(value)) {
     310          48 :                         unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
     311          48 :                         if (unicode == NULL) {
     312           0 :                                 return -1;
     313             :                         }
     314          48 :                         test_str = PyBytes_AS_STRING(unicode);
     315           0 :                 } else if (PyBytes_Check(value)) {
     316           0 :                         test_str = PyBytes_AS_STRING(value);
     317             :                 } else {
     318           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
     319           0 :                         return -1;
     320             :                 }
     321          48 :                 talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
     322          48 :                 if (unicode != NULL) {
     323          32 :                         Py_DECREF(unicode);
     324             :                 }
     325          48 :                 if (talloc_str == NULL) {
     326           0 :                         PyErr_NoMemory();
     327           0 :                         return -1;
     328             :                 }
     329          48 :                 object->ipaddr = talloc_str;
     330             :         }
     331          48 :         return 0;
     332             : }
     333             : 
     334             : static PyGetSetDef py_epm_rhs_ip_getsetters[] = {
     335             :         {
     336             :                 .name = discard_const_p(char, "ipaddr"),
     337             :                 .get = py_epm_rhs_ip_get_ipaddr,
     338             :                 .set = py_epm_rhs_ip_set_ipaddr,
     339             :                 .doc = discard_const_p(char, "PIDL-generated element of base type ipv4address")
     340             :         },
     341             :         { .name = NULL }
     342             : };
     343             : 
     344           0 : static PyObject *py_epm_rhs_ip_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     345             : {
     346           0 :         return pytalloc_new(struct epm_rhs_ip, type);
     347             : }
     348             : 
     349             : 
     350             : static PyTypeObject epm_rhs_ip_Type = {
     351             :         PyVarObject_HEAD_INIT(NULL, 0)
     352             :         .tp_name = "epmapper.epm_rhs_ip",
     353             :         .tp_getset = py_epm_rhs_ip_getsetters,
     354             :         .tp_methods = NULL,
     355             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     356             :         .tp_new = py_epm_rhs_ip_new,
     357             : };
     358             : 
     359             : 
     360           0 : static PyObject *py_epm_rhs_ncadg_get_minor_version(PyObject *obj, void *closure)
     361             : {
     362           0 :         struct epm_rhs_ncadg *object = pytalloc_get_ptr(obj);
     363           0 :         PyObject *py_minor_version;
     364           0 :         py_minor_version = PyLong_FromLong((uint16_t)(object->minor_version));
     365           0 :         return py_minor_version;
     366             : }
     367             : 
     368           0 : static int py_epm_rhs_ncadg_set_minor_version(PyObject *py_obj, PyObject *value, void *closure)
     369             : {
     370           0 :         struct epm_rhs_ncadg *object = pytalloc_get_ptr(py_obj);
     371           0 :         if (value == NULL) {
     372           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->minor_version");
     373           0 :                 return -1;
     374             :         }
     375             :         {
     376           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->minor_version));
     377           0 :                 if (PyLong_Check(value)) {
     378           0 :                         unsigned long long test_var;
     379           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
     380           0 :                         if (PyErr_Occurred() != NULL) {
     381           0 :                                 return -1;
     382             :                         }
     383           0 :                         if (test_var > uint_max) {
     384           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
     385             :                                   PyLong_Type.tp_name, uint_max, test_var);
     386           0 :                                 return -1;
     387             :                         }
     388           0 :                         object->minor_version = test_var;
     389             :                 } else {
     390           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
     391             :                           PyLong_Type.tp_name);
     392           0 :                         return -1;
     393             :                 }
     394             :         }
     395           0 :         return 0;
     396             : }
     397             : 
     398             : static PyGetSetDef py_epm_rhs_ncadg_getsetters[] = {
     399             :         {
     400             :                 .name = discard_const_p(char, "minor_version"),
     401             :                 .get = py_epm_rhs_ncadg_get_minor_version,
     402             :                 .set = py_epm_rhs_ncadg_set_minor_version,
     403             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
     404             :         },
     405             :         { .name = NULL }
     406             : };
     407             : 
     408           0 : static PyObject *py_epm_rhs_ncadg_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     409             : {
     410           0 :         return pytalloc_new(struct epm_rhs_ncadg, type);
     411             : }
     412             : 
     413             : 
     414             : static PyTypeObject epm_rhs_ncadg_Type = {
     415             :         PyVarObject_HEAD_INIT(NULL, 0)
     416             :         .tp_name = "epmapper.epm_rhs_ncadg",
     417             :         .tp_getset = py_epm_rhs_ncadg_getsetters,
     418             :         .tp_methods = NULL,
     419             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     420             :         .tp_new = py_epm_rhs_ncadg_new,
     421             : };
     422             : 
     423             : 
     424           0 : static PyObject *py_epm_rhs_ncacn_get_minor_version(PyObject *obj, void *closure)
     425             : {
     426           0 :         struct epm_rhs_ncacn *object = pytalloc_get_ptr(obj);
     427           0 :         PyObject *py_minor_version;
     428           0 :         py_minor_version = PyLong_FromLong((uint16_t)(object->minor_version));
     429           0 :         return py_minor_version;
     430             : }
     431             : 
     432          48 : static int py_epm_rhs_ncacn_set_minor_version(PyObject *py_obj, PyObject *value, void *closure)
     433             : {
     434          48 :         struct epm_rhs_ncacn *object = pytalloc_get_ptr(py_obj);
     435          48 :         if (value == NULL) {
     436           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->minor_version");
     437           0 :                 return -1;
     438             :         }
     439             :         {
     440          48 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->minor_version));
     441          48 :                 if (PyLong_Check(value)) {
     442           0 :                         unsigned long long test_var;
     443          48 :                         test_var = PyLong_AsUnsignedLongLong(value);
     444          48 :                         if (PyErr_Occurred() != NULL) {
     445           0 :                                 return -1;
     446             :                         }
     447          48 :                         if (test_var > uint_max) {
     448           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
     449             :                                   PyLong_Type.tp_name, uint_max, test_var);
     450           0 :                                 return -1;
     451             :                         }
     452          48 :                         object->minor_version = test_var;
     453             :                 } else {
     454           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
     455             :                           PyLong_Type.tp_name);
     456           0 :                         return -1;
     457             :                 }
     458             :         }
     459          48 :         return 0;
     460             : }
     461             : 
     462             : static PyGetSetDef py_epm_rhs_ncacn_getsetters[] = {
     463             :         {
     464             :                 .name = discard_const_p(char, "minor_version"),
     465             :                 .get = py_epm_rhs_ncacn_get_minor_version,
     466             :                 .set = py_epm_rhs_ncacn_set_minor_version,
     467             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
     468             :         },
     469             :         { .name = NULL }
     470             : };
     471             : 
     472           0 : static PyObject *py_epm_rhs_ncacn_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     473             : {
     474           0 :         return pytalloc_new(struct epm_rhs_ncacn, type);
     475             : }
     476             : 
     477             : 
     478             : static PyTypeObject epm_rhs_ncacn_Type = {
     479             :         PyVarObject_HEAD_INIT(NULL, 0)
     480             :         .tp_name = "epmapper.epm_rhs_ncacn",
     481             :         .tp_getset = py_epm_rhs_ncacn_getsetters,
     482             :         .tp_methods = NULL,
     483             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     484             :         .tp_new = py_epm_rhs_ncacn_new,
     485             : };
     486             : 
     487             : 
     488           0 : static PyObject *py_epm_rhs_uuid_get_unknown(PyObject *obj, void *closure)
     489             : {
     490           0 :         struct epm_rhs_uuid *object = pytalloc_get_ptr(obj);
     491           0 :         PyObject *py_unknown;
     492           0 :         py_unknown = PyBytes_FromStringAndSize((char *)(object->unknown).data, (object->unknown).length);
     493           0 :         return py_unknown;
     494             : }
     495             : 
     496          96 : static int py_epm_rhs_uuid_set_unknown(PyObject *py_obj, PyObject *value, void *closure)
     497             : {
     498          96 :         struct epm_rhs_uuid *object = pytalloc_get_ptr(py_obj);
     499          96 :         if (value == NULL) {
     500           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->unknown");
     501           0 :                 return -1;
     502             :         }
     503          96 :         object->unknown = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyBytes_AS_STRING(value), PyBytes_GET_SIZE(value));
     504          96 :         return 0;
     505             : }
     506             : 
     507             : static PyGetSetDef py_epm_rhs_uuid_getsetters[] = {
     508             :         {
     509             :                 .name = discard_const_p(char, "unknown"),
     510             :                 .get = py_epm_rhs_uuid_get_unknown,
     511             :                 .set = py_epm_rhs_uuid_set_unknown,
     512             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DATA_BLOB")
     513             :         },
     514             :         { .name = NULL }
     515             : };
     516             : 
     517          96 : static PyObject *py_epm_rhs_uuid_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     518             : {
     519          96 :         return pytalloc_new(struct epm_rhs_uuid, type);
     520             : }
     521             : 
     522             : 
     523             : static PyTypeObject epm_rhs_uuid_Type = {
     524             :         PyVarObject_HEAD_INIT(NULL, 0)
     525             :         .tp_name = "epmapper.epm_rhs_uuid",
     526             :         .tp_getset = py_epm_rhs_uuid_getsetters,
     527             :         .tp_methods = NULL,
     528             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     529             :         .tp_new = py_epm_rhs_uuid_new,
     530             : };
     531             : 
     532             : 
     533           0 : static PyObject *py_epm_rhs_ipx_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     534             : {
     535           0 :         return pytalloc_new(struct epm_rhs_ipx, type);
     536             : }
     537             : 
     538             : 
     539             : static PyTypeObject epm_rhs_ipx_Type = {
     540             :         PyVarObject_HEAD_INIT(NULL, 0)
     541             :         .tp_name = "epmapper.epm_rhs_ipx",
     542             :         .tp_getset = NULL,
     543             :         .tp_methods = NULL,
     544             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     545             :         .tp_new = py_epm_rhs_ipx_new,
     546             : };
     547             : 
     548             : 
     549           0 : static PyObject *py_epm_rhs_smb_get_unc(PyObject *obj, void *closure)
     550             : {
     551           0 :         struct epm_rhs_smb *object = pytalloc_get_ptr(obj);
     552           0 :         PyObject *py_unc;
     553           0 :         py_unc = PyString_FromStringOrNULL(object->unc);
     554           0 :         return py_unc;
     555             : }
     556             : 
     557           0 : static int py_epm_rhs_smb_set_unc(PyObject *py_obj, PyObject *value, void *closure)
     558             : {
     559           0 :         struct epm_rhs_smb *object = pytalloc_get_ptr(py_obj);
     560           0 :         if (value == NULL) {
     561           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->unc");
     562           0 :                 return -1;
     563             :         }
     564             :         {
     565           0 :                 const char *test_str;
     566           0 :                 const char *talloc_str;
     567           0 :                 PyObject *unicode = NULL;
     568           0 :                 if (PyUnicode_Check(value)) {
     569           0 :                         unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
     570           0 :                         if (unicode == NULL) {
     571           0 :                                 return -1;
     572             :                         }
     573           0 :                         test_str = PyBytes_AS_STRING(unicode);
     574           0 :                 } else if (PyBytes_Check(value)) {
     575           0 :                         test_str = PyBytes_AS_STRING(value);
     576             :                 } else {
     577           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
     578           0 :                         return -1;
     579             :                 }
     580           0 :                 talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
     581           0 :                 if (unicode != NULL) {
     582           0 :                         Py_DECREF(unicode);
     583             :                 }
     584           0 :                 if (talloc_str == NULL) {
     585           0 :                         PyErr_NoMemory();
     586           0 :                         return -1;
     587             :                 }
     588           0 :                 object->unc = talloc_str;
     589             :         }
     590           0 :         return 0;
     591             : }
     592             : 
     593             : static PyGetSetDef py_epm_rhs_smb_getsetters[] = {
     594             :         {
     595             :                 .name = discard_const_p(char, "unc"),
     596             :                 .get = py_epm_rhs_smb_get_unc,
     597             :                 .set = py_epm_rhs_smb_set_unc,
     598             :                 .doc = discard_const_p(char, "PIDL-generated element of base type string")
     599             :         },
     600             :         { .name = NULL }
     601             : };
     602             : 
     603           0 : static PyObject *py_epm_rhs_smb_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     604             : {
     605           0 :         return pytalloc_new(struct epm_rhs_smb, type);
     606             : }
     607             : 
     608             : 
     609             : static PyTypeObject epm_rhs_smb_Type = {
     610             :         PyVarObject_HEAD_INIT(NULL, 0)
     611             :         .tp_name = "epmapper.epm_rhs_smb",
     612             :         .tp_getset = py_epm_rhs_smb_getsetters,
     613             :         .tp_methods = NULL,
     614             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     615             :         .tp_new = py_epm_rhs_smb_new,
     616             : };
     617             : 
     618             : 
     619           0 : static PyObject *py_epm_rhs_named_pipe_get_path(PyObject *obj, void *closure)
     620             : {
     621           0 :         struct epm_rhs_named_pipe *object = pytalloc_get_ptr(obj);
     622           0 :         PyObject *py_path;
     623           0 :         py_path = PyString_FromStringOrNULL(object->path);
     624           0 :         return py_path;
     625             : }
     626             : 
     627           0 : static int py_epm_rhs_named_pipe_set_path(PyObject *py_obj, PyObject *value, void *closure)
     628             : {
     629           0 :         struct epm_rhs_named_pipe *object = pytalloc_get_ptr(py_obj);
     630           0 :         if (value == NULL) {
     631           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->path");
     632           0 :                 return -1;
     633             :         }
     634             :         {
     635           0 :                 const char *test_str;
     636           0 :                 const char *talloc_str;
     637           0 :                 PyObject *unicode = NULL;
     638           0 :                 if (PyUnicode_Check(value)) {
     639           0 :                         unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
     640           0 :                         if (unicode == NULL) {
     641           0 :                                 return -1;
     642             :                         }
     643           0 :                         test_str = PyBytes_AS_STRING(unicode);
     644           0 :                 } else if (PyBytes_Check(value)) {
     645           0 :                         test_str = PyBytes_AS_STRING(value);
     646             :                 } else {
     647           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
     648           0 :                         return -1;
     649             :                 }
     650           0 :                 talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
     651           0 :                 if (unicode != NULL) {
     652           0 :                         Py_DECREF(unicode);
     653             :                 }
     654           0 :                 if (talloc_str == NULL) {
     655           0 :                         PyErr_NoMemory();
     656           0 :                         return -1;
     657             :                 }
     658           0 :                 object->path = talloc_str;
     659             :         }
     660           0 :         return 0;
     661             : }
     662             : 
     663             : static PyGetSetDef py_epm_rhs_named_pipe_getsetters[] = {
     664             :         {
     665             :                 .name = discard_const_p(char, "path"),
     666             :                 .get = py_epm_rhs_named_pipe_get_path,
     667             :                 .set = py_epm_rhs_named_pipe_set_path,
     668             :                 .doc = discard_const_p(char, "PIDL-generated element of base type string")
     669             :         },
     670             :         { .name = NULL }
     671             : };
     672             : 
     673           0 : static PyObject *py_epm_rhs_named_pipe_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     674             : {
     675           0 :         return pytalloc_new(struct epm_rhs_named_pipe, type);
     676             : }
     677             : 
     678             : 
     679             : static PyTypeObject epm_rhs_named_pipe_Type = {
     680             :         PyVarObject_HEAD_INIT(NULL, 0)
     681             :         .tp_name = "epmapper.epm_rhs_named_pipe",
     682             :         .tp_getset = py_epm_rhs_named_pipe_getsetters,
     683             :         .tp_methods = NULL,
     684             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     685             :         .tp_new = py_epm_rhs_named_pipe_new,
     686             : };
     687             : 
     688             : 
     689           0 : static PyObject *py_epm_rhs_netbios_get_name(PyObject *obj, void *closure)
     690             : {
     691           0 :         struct epm_rhs_netbios *object = pytalloc_get_ptr(obj);
     692           0 :         PyObject *py_name;
     693           0 :         py_name = PyString_FromStringOrNULL(object->name);
     694           0 :         return py_name;
     695             : }
     696             : 
     697           0 : static int py_epm_rhs_netbios_set_name(PyObject *py_obj, PyObject *value, void *closure)
     698             : {
     699           0 :         struct epm_rhs_netbios *object = pytalloc_get_ptr(py_obj);
     700           0 :         if (value == NULL) {
     701           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->name");
     702           0 :                 return -1;
     703             :         }
     704             :         {
     705           0 :                 const char *test_str;
     706           0 :                 const char *talloc_str;
     707           0 :                 PyObject *unicode = NULL;
     708           0 :                 if (PyUnicode_Check(value)) {
     709           0 :                         unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
     710           0 :                         if (unicode == NULL) {
     711           0 :                                 return -1;
     712             :                         }
     713           0 :                         test_str = PyBytes_AS_STRING(unicode);
     714           0 :                 } else if (PyBytes_Check(value)) {
     715           0 :                         test_str = PyBytes_AS_STRING(value);
     716             :                 } else {
     717           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
     718           0 :                         return -1;
     719             :                 }
     720           0 :                 talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
     721           0 :                 if (unicode != NULL) {
     722           0 :                         Py_DECREF(unicode);
     723             :                 }
     724           0 :                 if (talloc_str == NULL) {
     725           0 :                         PyErr_NoMemory();
     726           0 :                         return -1;
     727             :                 }
     728           0 :                 object->name = talloc_str;
     729             :         }
     730           0 :         return 0;
     731             : }
     732             : 
     733             : static PyGetSetDef py_epm_rhs_netbios_getsetters[] = {
     734             :         {
     735             :                 .name = discard_const_p(char, "name"),
     736             :                 .get = py_epm_rhs_netbios_get_name,
     737             :                 .set = py_epm_rhs_netbios_set_name,
     738             :                 .doc = discard_const_p(char, "PIDL-generated element of base type string")
     739             :         },
     740             :         { .name = NULL }
     741             : };
     742             : 
     743           0 : static PyObject *py_epm_rhs_netbios_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     744             : {
     745           0 :         return pytalloc_new(struct epm_rhs_netbios, type);
     746             : }
     747             : 
     748             : 
     749             : static PyTypeObject epm_rhs_netbios_Type = {
     750             :         PyVarObject_HEAD_INIT(NULL, 0)
     751             :         .tp_name = "epmapper.epm_rhs_netbios",
     752             :         .tp_getset = py_epm_rhs_netbios_getsetters,
     753             :         .tp_methods = NULL,
     754             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     755             :         .tp_new = py_epm_rhs_netbios_new,
     756             : };
     757             : 
     758             : 
     759           0 : static PyObject *py_epm_rhs_netbeui_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     760             : {
     761           0 :         return pytalloc_new(struct epm_rhs_netbeui, type);
     762             : }
     763             : 
     764             : 
     765             : static PyTypeObject epm_rhs_netbeui_Type = {
     766             :         PyVarObject_HEAD_INIT(NULL, 0)
     767             :         .tp_name = "epmapper.epm_rhs_netbeui",
     768             :         .tp_getset = NULL,
     769             :         .tp_methods = NULL,
     770             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     771             :         .tp_new = py_epm_rhs_netbeui_new,
     772             : };
     773             : 
     774             : 
     775           0 : static PyObject *py_epm_rhs_spx_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     776             : {
     777           0 :         return pytalloc_new(struct epm_rhs_spx, type);
     778             : }
     779             : 
     780             : 
     781             : static PyTypeObject epm_rhs_spx_Type = {
     782             :         PyVarObject_HEAD_INIT(NULL, 0)
     783             :         .tp_name = "epmapper.epm_rhs_spx",
     784             :         .tp_getset = NULL,
     785             :         .tp_methods = NULL,
     786             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     787             :         .tp_new = py_epm_rhs_spx_new,
     788             : };
     789             : 
     790             : 
     791           0 : static PyObject *py_epm_rhs_nb_ipx_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     792             : {
     793           0 :         return pytalloc_new(struct epm_rhs_nb_ipx, type);
     794             : }
     795             : 
     796             : 
     797             : static PyTypeObject epm_rhs_nb_ipx_Type = {
     798             :         PyVarObject_HEAD_INIT(NULL, 0)
     799             :         .tp_name = "epmapper.epm_rhs_nb_ipx",
     800             :         .tp_getset = NULL,
     801             :         .tp_methods = NULL,
     802             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     803             :         .tp_new = py_epm_rhs_nb_ipx_new,
     804             : };
     805             : 
     806             : 
     807           0 : static PyObject *py_epm_rhs_http_get_port(PyObject *obj, void *closure)
     808             : {
     809           0 :         struct epm_rhs_http *object = pytalloc_get_ptr(obj);
     810           0 :         PyObject *py_port;
     811           0 :         py_port = PyLong_FromLong((uint16_t)(object->port));
     812           0 :         return py_port;
     813             : }
     814             : 
     815           0 : static int py_epm_rhs_http_set_port(PyObject *py_obj, PyObject *value, void *closure)
     816             : {
     817           0 :         struct epm_rhs_http *object = pytalloc_get_ptr(py_obj);
     818           0 :         if (value == NULL) {
     819           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->port");
     820           0 :                 return -1;
     821             :         }
     822             :         {
     823           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->port));
     824           0 :                 if (PyLong_Check(value)) {
     825           0 :                         unsigned long long test_var;
     826           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
     827           0 :                         if (PyErr_Occurred() != NULL) {
     828           0 :                                 return -1;
     829             :                         }
     830           0 :                         if (test_var > uint_max) {
     831           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
     832             :                                   PyLong_Type.tp_name, uint_max, test_var);
     833           0 :                                 return -1;
     834             :                         }
     835           0 :                         object->port = test_var;
     836             :                 } else {
     837           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
     838             :                           PyLong_Type.tp_name);
     839           0 :                         return -1;
     840             :                 }
     841             :         }
     842           0 :         return 0;
     843             : }
     844             : 
     845             : static PyGetSetDef py_epm_rhs_http_getsetters[] = {
     846             :         {
     847             :                 .name = discard_const_p(char, "port"),
     848             :                 .get = py_epm_rhs_http_get_port,
     849             :                 .set = py_epm_rhs_http_set_port,
     850             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
     851             :         },
     852             :         { .name = NULL }
     853             : };
     854             : 
     855           0 : static PyObject *py_epm_rhs_http_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     856             : {
     857           0 :         return pytalloc_new(struct epm_rhs_http, type);
     858             : }
     859             : 
     860             : 
     861             : static PyTypeObject epm_rhs_http_Type = {
     862             :         PyVarObject_HEAD_INIT(NULL, 0)
     863             :         .tp_name = "epmapper.epm_rhs_http",
     864             :         .tp_getset = py_epm_rhs_http_getsetters,
     865             :         .tp_methods = NULL,
     866             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     867             :         .tp_new = py_epm_rhs_http_new,
     868             : };
     869             : 
     870             : 
     871           0 : static PyObject *py_epm_rhs_unix_ds_get_path(PyObject *obj, void *closure)
     872             : {
     873           0 :         struct epm_rhs_unix_ds *object = pytalloc_get_ptr(obj);
     874           0 :         PyObject *py_path;
     875           0 :         py_path = PyString_FromStringOrNULL(object->path);
     876           0 :         return py_path;
     877             : }
     878             : 
     879           0 : static int py_epm_rhs_unix_ds_set_path(PyObject *py_obj, PyObject *value, void *closure)
     880             : {
     881           0 :         struct epm_rhs_unix_ds *object = pytalloc_get_ptr(py_obj);
     882           0 :         if (value == NULL) {
     883           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->path");
     884           0 :                 return -1;
     885             :         }
     886             :         {
     887           0 :                 const char *test_str;
     888           0 :                 const char *talloc_str;
     889           0 :                 PyObject *unicode = NULL;
     890           0 :                 if (PyUnicode_Check(value)) {
     891           0 :                         unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
     892           0 :                         if (unicode == NULL) {
     893           0 :                                 return -1;
     894             :                         }
     895           0 :                         test_str = PyBytes_AS_STRING(unicode);
     896           0 :                 } else if (PyBytes_Check(value)) {
     897           0 :                         test_str = PyBytes_AS_STRING(value);
     898             :                 } else {
     899           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
     900           0 :                         return -1;
     901             :                 }
     902           0 :                 talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
     903           0 :                 if (unicode != NULL) {
     904           0 :                         Py_DECREF(unicode);
     905             :                 }
     906           0 :                 if (talloc_str == NULL) {
     907           0 :                         PyErr_NoMemory();
     908           0 :                         return -1;
     909             :                 }
     910           0 :                 object->path = talloc_str;
     911             :         }
     912           0 :         return 0;
     913             : }
     914             : 
     915             : static PyGetSetDef py_epm_rhs_unix_ds_getsetters[] = {
     916             :         {
     917             :                 .name = discard_const_p(char, "path"),
     918             :                 .get = py_epm_rhs_unix_ds_get_path,
     919             :                 .set = py_epm_rhs_unix_ds_set_path,
     920             :                 .doc = discard_const_p(char, "PIDL-generated element of base type string")
     921             :         },
     922             :         { .name = NULL }
     923             : };
     924             : 
     925           0 : static PyObject *py_epm_rhs_unix_ds_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     926             : {
     927           0 :         return pytalloc_new(struct epm_rhs_unix_ds, type);
     928             : }
     929             : 
     930             : 
     931             : static PyTypeObject epm_rhs_unix_ds_Type = {
     932             :         PyVarObject_HEAD_INIT(NULL, 0)
     933             :         .tp_name = "epmapper.epm_rhs_unix_ds",
     934             :         .tp_getset = py_epm_rhs_unix_ds_getsetters,
     935             :         .tp_methods = NULL,
     936             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     937             :         .tp_new = py_epm_rhs_unix_ds_new,
     938             : };
     939             : 
     940             : 
     941           0 : static PyObject *py_epm_rhs_null_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     942             : {
     943           0 :         return pytalloc_new(struct epm_rhs_null, type);
     944             : }
     945             : 
     946             : 
     947             : static PyTypeObject epm_rhs_null_Type = {
     948             :         PyVarObject_HEAD_INIT(NULL, 0)
     949             :         .tp_name = "epmapper.epm_rhs_null",
     950             :         .tp_getset = NULL,
     951             :         .tp_methods = NULL,
     952             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     953             :         .tp_new = py_epm_rhs_null_new,
     954             : };
     955             : 
     956             : 
     957           0 : static PyObject *py_epm_rhs_ncalrpc_get_minor_version(PyObject *obj, void *closure)
     958             : {
     959           0 :         struct epm_rhs_ncalrpc *object = pytalloc_get_ptr(obj);
     960           0 :         PyObject *py_minor_version;
     961           0 :         py_minor_version = PyLong_FromLong((uint16_t)(object->minor_version));
     962           0 :         return py_minor_version;
     963             : }
     964             : 
     965           0 : static int py_epm_rhs_ncalrpc_set_minor_version(PyObject *py_obj, PyObject *value, void *closure)
     966             : {
     967           0 :         struct epm_rhs_ncalrpc *object = pytalloc_get_ptr(py_obj);
     968           0 :         if (value == NULL) {
     969           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->minor_version");
     970           0 :                 return -1;
     971             :         }
     972             :         {
     973           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->minor_version));
     974           0 :                 if (PyLong_Check(value)) {
     975           0 :                         unsigned long long test_var;
     976           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
     977           0 :                         if (PyErr_Occurred() != NULL) {
     978           0 :                                 return -1;
     979             :                         }
     980           0 :                         if (test_var > uint_max) {
     981           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
     982             :                                   PyLong_Type.tp_name, uint_max, test_var);
     983           0 :                                 return -1;
     984             :                         }
     985           0 :                         object->minor_version = test_var;
     986             :                 } else {
     987           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
     988             :                           PyLong_Type.tp_name);
     989           0 :                         return -1;
     990             :                 }
     991             :         }
     992           0 :         return 0;
     993             : }
     994             : 
     995             : static PyGetSetDef py_epm_rhs_ncalrpc_getsetters[] = {
     996             :         {
     997             :                 .name = discard_const_p(char, "minor_version"),
     998             :                 .get = py_epm_rhs_ncalrpc_get_minor_version,
     999             :                 .set = py_epm_rhs_ncalrpc_set_minor_version,
    1000             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
    1001             :         },
    1002             :         { .name = NULL }
    1003             : };
    1004             : 
    1005           0 : static PyObject *py_epm_rhs_ncalrpc_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    1006             : {
    1007           0 :         return pytalloc_new(struct epm_rhs_ncalrpc, type);
    1008             : }
    1009             : 
    1010             : 
    1011             : static PyTypeObject epm_rhs_ncalrpc_Type = {
    1012             :         PyVarObject_HEAD_INIT(NULL, 0)
    1013             :         .tp_name = "epmapper.epm_rhs_ncalrpc",
    1014             :         .tp_getset = py_epm_rhs_ncalrpc_getsetters,
    1015             :         .tp_methods = NULL,
    1016             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    1017             :         .tp_new = py_epm_rhs_ncalrpc_new,
    1018             : };
    1019             : 
    1020             : 
    1021           0 : static PyObject *py_epm_rhs_appletalk_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    1022             : {
    1023           0 :         return pytalloc_new(struct epm_rhs_appletalk, type);
    1024             : }
    1025             : 
    1026             : 
    1027             : static PyTypeObject epm_rhs_appletalk_Type = {
    1028             :         PyVarObject_HEAD_INIT(NULL, 0)
    1029             :         .tp_name = "epmapper.epm_rhs_appletalk",
    1030             :         .tp_getset = NULL,
    1031             :         .tp_methods = NULL,
    1032             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    1033             :         .tp_new = py_epm_rhs_appletalk_new,
    1034             : };
    1035             : 
    1036             : 
    1037           0 : static PyObject *py_epm_rhs_atalk_stream_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    1038             : {
    1039           0 :         return pytalloc_new(struct epm_rhs_atalk_stream, type);
    1040             : }
    1041             : 
    1042             : 
    1043             : static PyTypeObject epm_rhs_atalk_stream_Type = {
    1044             :         PyVarObject_HEAD_INIT(NULL, 0)
    1045             :         .tp_name = "epmapper.epm_rhs_atalk_stream",
    1046             :         .tp_getset = NULL,
    1047             :         .tp_methods = NULL,
    1048             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    1049             :         .tp_new = py_epm_rhs_atalk_stream_new,
    1050             : };
    1051             : 
    1052             : 
    1053           0 : static PyObject *py_epm_rhs_atalk_datagram_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    1054             : {
    1055           0 :         return pytalloc_new(struct epm_rhs_atalk_datagram, type);
    1056             : }
    1057             : 
    1058             : 
    1059             : static PyTypeObject epm_rhs_atalk_datagram_Type = {
    1060             :         PyVarObject_HEAD_INIT(NULL, 0)
    1061             :         .tp_name = "epmapper.epm_rhs_atalk_datagram",
    1062             :         .tp_getset = NULL,
    1063             :         .tp_methods = NULL,
    1064             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    1065             :         .tp_new = py_epm_rhs_atalk_datagram_new,
    1066             : };
    1067             : 
    1068             : 
    1069           0 : static PyObject *py_epm_rhs_vines_spp_get_port(PyObject *obj, void *closure)
    1070             : {
    1071           0 :         struct epm_rhs_vines_spp *object = pytalloc_get_ptr(obj);
    1072           0 :         PyObject *py_port;
    1073           0 :         py_port = PyLong_FromLong((uint16_t)(object->port));
    1074           0 :         return py_port;
    1075             : }
    1076             : 
    1077           0 : static int py_epm_rhs_vines_spp_set_port(PyObject *py_obj, PyObject *value, void *closure)
    1078             : {
    1079           0 :         struct epm_rhs_vines_spp *object = pytalloc_get_ptr(py_obj);
    1080           0 :         if (value == NULL) {
    1081           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->port");
    1082           0 :                 return -1;
    1083             :         }
    1084             :         {
    1085           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->port));
    1086           0 :                 if (PyLong_Check(value)) {
    1087           0 :                         unsigned long long test_var;
    1088           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    1089           0 :                         if (PyErr_Occurred() != NULL) {
    1090           0 :                                 return -1;
    1091             :                         }
    1092           0 :                         if (test_var > uint_max) {
    1093           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    1094             :                                   PyLong_Type.tp_name, uint_max, test_var);
    1095           0 :                                 return -1;
    1096             :                         }
    1097           0 :                         object->port = test_var;
    1098             :                 } else {
    1099           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1100             :                           PyLong_Type.tp_name);
    1101           0 :                         return -1;
    1102             :                 }
    1103             :         }
    1104           0 :         return 0;
    1105             : }
    1106             : 
    1107             : static PyGetSetDef py_epm_rhs_vines_spp_getsetters[] = {
    1108             :         {
    1109             :                 .name = discard_const_p(char, "port"),
    1110             :                 .get = py_epm_rhs_vines_spp_get_port,
    1111             :                 .set = py_epm_rhs_vines_spp_set_port,
    1112             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
    1113             :         },
    1114             :         { .name = NULL }
    1115             : };
    1116             : 
    1117           0 : static PyObject *py_epm_rhs_vines_spp_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    1118             : {
    1119           0 :         return pytalloc_new(struct epm_rhs_vines_spp, type);
    1120             : }
    1121             : 
    1122             : 
    1123             : static PyTypeObject epm_rhs_vines_spp_Type = {
    1124             :         PyVarObject_HEAD_INIT(NULL, 0)
    1125             :         .tp_name = "epmapper.epm_rhs_vines_spp",
    1126             :         .tp_getset = py_epm_rhs_vines_spp_getsetters,
    1127             :         .tp_methods = NULL,
    1128             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    1129             :         .tp_new = py_epm_rhs_vines_spp_new,
    1130             : };
    1131             : 
    1132             : 
    1133           0 : static PyObject *py_epm_rhs_vines_ipc_get_port(PyObject *obj, void *closure)
    1134             : {
    1135           0 :         struct epm_rhs_vines_ipc *object = pytalloc_get_ptr(obj);
    1136           0 :         PyObject *py_port;
    1137           0 :         py_port = PyLong_FromLong((uint16_t)(object->port));
    1138           0 :         return py_port;
    1139             : }
    1140             : 
    1141           0 : static int py_epm_rhs_vines_ipc_set_port(PyObject *py_obj, PyObject *value, void *closure)
    1142             : {
    1143           0 :         struct epm_rhs_vines_ipc *object = pytalloc_get_ptr(py_obj);
    1144           0 :         if (value == NULL) {
    1145           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->port");
    1146           0 :                 return -1;
    1147             :         }
    1148             :         {
    1149           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->port));
    1150           0 :                 if (PyLong_Check(value)) {
    1151           0 :                         unsigned long long test_var;
    1152           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    1153           0 :                         if (PyErr_Occurred() != NULL) {
    1154           0 :                                 return -1;
    1155             :                         }
    1156           0 :                         if (test_var > uint_max) {
    1157           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    1158             :                                   PyLong_Type.tp_name, uint_max, test_var);
    1159           0 :                                 return -1;
    1160             :                         }
    1161           0 :                         object->port = test_var;
    1162             :                 } else {
    1163           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1164             :                           PyLong_Type.tp_name);
    1165           0 :                         return -1;
    1166             :                 }
    1167             :         }
    1168           0 :         return 0;
    1169             : }
    1170             : 
    1171             : static PyGetSetDef py_epm_rhs_vines_ipc_getsetters[] = {
    1172             :         {
    1173             :                 .name = discard_const_p(char, "port"),
    1174             :                 .get = py_epm_rhs_vines_ipc_get_port,
    1175             :                 .set = py_epm_rhs_vines_ipc_set_port,
    1176             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
    1177             :         },
    1178             :         { .name = NULL }
    1179             : };
    1180             : 
    1181           0 : static PyObject *py_epm_rhs_vines_ipc_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    1182             : {
    1183           0 :         return pytalloc_new(struct epm_rhs_vines_ipc, type);
    1184             : }
    1185             : 
    1186             : 
    1187             : static PyTypeObject epm_rhs_vines_ipc_Type = {
    1188             :         PyVarObject_HEAD_INIT(NULL, 0)
    1189             :         .tp_name = "epmapper.epm_rhs_vines_ipc",
    1190             :         .tp_getset = py_epm_rhs_vines_ipc_getsetters,
    1191             :         .tp_methods = NULL,
    1192             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    1193             :         .tp_new = py_epm_rhs_vines_ipc_new,
    1194             : };
    1195             : 
    1196             : 
    1197           0 : static PyObject *py_epm_rhs_streettalk_get_streettalk(PyObject *obj, void *closure)
    1198             : {
    1199           0 :         struct epm_rhs_streettalk *object = pytalloc_get_ptr(obj);
    1200           0 :         PyObject *py_streettalk;
    1201           0 :         py_streettalk = PyString_FromStringOrNULL(object->streettalk);
    1202           0 :         return py_streettalk;
    1203             : }
    1204             : 
    1205           0 : static int py_epm_rhs_streettalk_set_streettalk(PyObject *py_obj, PyObject *value, void *closure)
    1206             : {
    1207           0 :         struct epm_rhs_streettalk *object = pytalloc_get_ptr(py_obj);
    1208           0 :         if (value == NULL) {
    1209           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->streettalk");
    1210           0 :                 return -1;
    1211             :         }
    1212             :         {
    1213           0 :                 const char *test_str;
    1214           0 :                 const char *talloc_str;
    1215           0 :                 PyObject *unicode = NULL;
    1216           0 :                 if (PyUnicode_Check(value)) {
    1217           0 :                         unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    1218           0 :                         if (unicode == NULL) {
    1219           0 :                                 return -1;
    1220             :                         }
    1221           0 :                         test_str = PyBytes_AS_STRING(unicode);
    1222           0 :                 } else if (PyBytes_Check(value)) {
    1223           0 :                         test_str = PyBytes_AS_STRING(value);
    1224             :                 } else {
    1225           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    1226           0 :                         return -1;
    1227             :                 }
    1228           0 :                 talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    1229           0 :                 if (unicode != NULL) {
    1230           0 :                         Py_DECREF(unicode);
    1231             :                 }
    1232           0 :                 if (talloc_str == NULL) {
    1233           0 :                         PyErr_NoMemory();
    1234           0 :                         return -1;
    1235             :                 }
    1236           0 :                 object->streettalk = talloc_str;
    1237             :         }
    1238           0 :         return 0;
    1239             : }
    1240             : 
    1241             : static PyGetSetDef py_epm_rhs_streettalk_getsetters[] = {
    1242             :         {
    1243             :                 .name = discard_const_p(char, "streettalk"),
    1244             :                 .get = py_epm_rhs_streettalk_get_streettalk,
    1245             :                 .set = py_epm_rhs_streettalk_set_streettalk,
    1246             :                 .doc = discard_const_p(char, "PIDL-generated element of base type string")
    1247             :         },
    1248             :         { .name = NULL }
    1249             : };
    1250             : 
    1251           0 : static PyObject *py_epm_rhs_streettalk_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    1252             : {
    1253           0 :         return pytalloc_new(struct epm_rhs_streettalk, type);
    1254             : }
    1255             : 
    1256             : 
    1257             : static PyTypeObject epm_rhs_streettalk_Type = {
    1258             :         PyVarObject_HEAD_INIT(NULL, 0)
    1259             :         .tp_name = "epmapper.epm_rhs_streettalk",
    1260             :         .tp_getset = py_epm_rhs_streettalk_getsetters,
    1261             :         .tp_methods = NULL,
    1262             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    1263             :         .tp_new = py_epm_rhs_streettalk_new,
    1264             : };
    1265             : 
    1266         160 : static PyObject *py_import_epm_rhs(TALLOC_CTX *mem_ctx, int level, union epm_rhs *in)
    1267             : {
    1268           0 :         PyObject *ret;
    1269             : 
    1270         160 :         switch (level) {
    1271           0 :                 case EPM_PROTOCOL_DNET_NSP:
    1272           0 :                         ret = pytalloc_reference_ex(&epm_rhs_dnet_nsp_Type, mem_ctx, &in->dnet_nsp);
    1273           0 :                         return ret;
    1274             : 
    1275           0 :                 case EPM_PROTOCOL_OSI_TP4:
    1276           0 :                         ret = pytalloc_reference_ex(&epm_rhs_osi_tp4_Type, mem_ctx, &in->osi_tp4);
    1277           0 :                         return ret;
    1278             : 
    1279           0 :                 case EPM_PROTOCOL_OSI_CLNS:
    1280           0 :                         ret = pytalloc_reference_ex(&epm_rhs_osi_clns_Type, mem_ctx, &in->osi_clns);
    1281           0 :                         return ret;
    1282             : 
    1283          64 :                 case EPM_PROTOCOL_TCP:
    1284          64 :                         ret = pytalloc_reference_ex(&epm_rhs_tcp_Type, mem_ctx, &in->tcp);
    1285          64 :                         return ret;
    1286             : 
    1287           0 :                 case EPM_PROTOCOL_UDP:
    1288           0 :                         ret = pytalloc_reference_ex(&epm_rhs_udp_Type, mem_ctx, &in->udp);
    1289           0 :                         return ret;
    1290             : 
    1291          48 :                 case EPM_PROTOCOL_IP:
    1292          48 :                         ret = pytalloc_reference_ex(&epm_rhs_ip_Type, mem_ctx, &in->ip);
    1293          48 :                         return ret;
    1294             : 
    1295           0 :                 case EPM_PROTOCOL_NCADG:
    1296           0 :                         ret = pytalloc_reference_ex(&epm_rhs_ncadg_Type, mem_ctx, &in->ncadg);
    1297           0 :                         return ret;
    1298             : 
    1299          48 :                 case EPM_PROTOCOL_NCACN:
    1300          48 :                         ret = pytalloc_reference_ex(&epm_rhs_ncacn_Type, mem_ctx, &in->ncacn);
    1301          48 :                         return ret;
    1302             : 
    1303           0 :                 case EPM_PROTOCOL_NCALRPC:
    1304           0 :                         ret = pytalloc_reference_ex(&epm_rhs_ncalrpc_Type, mem_ctx, &in->ncalrpc);
    1305           0 :                         return ret;
    1306             : 
    1307           0 :                 case EPM_PROTOCOL_UUID:
    1308           0 :                         ret = pytalloc_reference_ex(&epm_rhs_uuid_Type, mem_ctx, &in->uuid);
    1309           0 :                         return ret;
    1310             : 
    1311           0 :                 case EPM_PROTOCOL_IPX:
    1312           0 :                         ret = pytalloc_reference_ex(&epm_rhs_ipx_Type, mem_ctx, &in->ipx);
    1313           0 :                         return ret;
    1314             : 
    1315           0 :                 case EPM_PROTOCOL_SMB:
    1316           0 :                         ret = pytalloc_reference_ex(&epm_rhs_smb_Type, mem_ctx, &in->smb);
    1317           0 :                         return ret;
    1318             : 
    1319           0 :                 case EPM_PROTOCOL_NAMED_PIPE:
    1320           0 :                         ret = pytalloc_reference_ex(&epm_rhs_named_pipe_Type, mem_ctx, &in->named_pipe);
    1321           0 :                         return ret;
    1322             : 
    1323           0 :                 case EPM_PROTOCOL_NETBIOS:
    1324           0 :                         ret = pytalloc_reference_ex(&epm_rhs_netbios_Type, mem_ctx, &in->netbios);
    1325           0 :                         return ret;
    1326             : 
    1327           0 :                 case EPM_PROTOCOL_NETBEUI:
    1328           0 :                         ret = pytalloc_reference_ex(&epm_rhs_netbeui_Type, mem_ctx, &in->netbeui);
    1329           0 :                         return ret;
    1330             : 
    1331           0 :                 case EPM_PROTOCOL_SPX:
    1332           0 :                         ret = pytalloc_reference_ex(&epm_rhs_spx_Type, mem_ctx, &in->spx);
    1333           0 :                         return ret;
    1334             : 
    1335           0 :                 case EPM_PROTOCOL_NB_IPX:
    1336           0 :                         ret = pytalloc_reference_ex(&epm_rhs_nb_ipx_Type, mem_ctx, &in->nb_ipx);
    1337           0 :                         return ret;
    1338             : 
    1339           0 :                 case EPM_PROTOCOL_DSP:
    1340           0 :                         ret = pytalloc_reference_ex(&epm_rhs_atalk_stream_Type, mem_ctx, &in->atalk_stream);
    1341           0 :                         return ret;
    1342             : 
    1343           0 :                 case EPM_PROTOCOL_DDP:
    1344           0 :                         ret = pytalloc_reference_ex(&epm_rhs_atalk_datagram_Type, mem_ctx, &in->atalk_datagram);
    1345           0 :                         return ret;
    1346             : 
    1347           0 :                 case EPM_PROTOCOL_APPLETALK:
    1348           0 :                         ret = pytalloc_reference_ex(&epm_rhs_appletalk_Type, mem_ctx, &in->appletalk);
    1349           0 :                         return ret;
    1350             : 
    1351           0 :                 case EPM_PROTOCOL_VINES_SPP:
    1352           0 :                         ret = pytalloc_reference_ex(&epm_rhs_vines_spp_Type, mem_ctx, &in->vines_spp);
    1353           0 :                         return ret;
    1354             : 
    1355           0 :                 case EPM_PROTOCOL_VINES_IPC:
    1356           0 :                         ret = pytalloc_reference_ex(&epm_rhs_vines_ipc_Type, mem_ctx, &in->vines_ipc);
    1357           0 :                         return ret;
    1358             : 
    1359           0 :                 case EPM_PROTOCOL_STREETTALK:
    1360           0 :                         ret = pytalloc_reference_ex(&epm_rhs_streettalk_Type, mem_ctx, &in->streettalk);
    1361           0 :                         return ret;
    1362             : 
    1363           0 :                 case EPM_PROTOCOL_HTTP:
    1364           0 :                         ret = pytalloc_reference_ex(&epm_rhs_http_Type, mem_ctx, &in->http);
    1365           0 :                         return ret;
    1366             : 
    1367           0 :                 case EPM_PROTOCOL_UNIX_DS:
    1368           0 :                         ret = pytalloc_reference_ex(&epm_rhs_unix_ds_Type, mem_ctx, &in->unix_ds);
    1369           0 :                         return ret;
    1370             : 
    1371           0 :                 case EPM_PROTOCOL_NULL:
    1372           0 :                         ret = pytalloc_reference_ex(&epm_rhs_null_Type, mem_ctx, &in->null);
    1373           0 :                         return ret;
    1374             : 
    1375           0 :                 default:
    1376           0 :                         ret = PyBytes_FromStringAndSize((char *)(in->unknown).data, (in->unknown).length);
    1377           0 :                         return ret;
    1378             : 
    1379             :         }
    1380             :         PyErr_SetString(PyExc_TypeError, "unknown union level");
    1381             :         return NULL;
    1382             : }
    1383             : 
    1384          96 : static union epm_rhs *py_export_epm_rhs(TALLOC_CTX *mem_ctx, int level, PyObject *in)
    1385             : {
    1386          96 :         union epm_rhs *ret = talloc_zero(mem_ctx, union epm_rhs);
    1387          96 :         switch (level) {
    1388           0 :                 case EPM_PROTOCOL_DNET_NSP:
    1389           0 :                         if (in == NULL) {
    1390           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->dnet_nsp");
    1391           0 :                                 talloc_free(ret); return NULL;
    1392             :                         }
    1393           0 :                         PY_CHECK_TYPE(&epm_rhs_dnet_nsp_Type, in, talloc_free(ret); return NULL;);
    1394           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1395           0 :                                 PyErr_NoMemory();
    1396           0 :                                 talloc_free(ret); return NULL;
    1397             :                         }
    1398           0 :                         ret->dnet_nsp = *(struct epm_rhs_dnet_nsp *)pytalloc_get_ptr(in);
    1399           0 :                         break;
    1400             : 
    1401           0 :                 case EPM_PROTOCOL_OSI_TP4:
    1402           0 :                         if (in == NULL) {
    1403           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->osi_tp4");
    1404           0 :                                 talloc_free(ret); return NULL;
    1405             :                         }
    1406           0 :                         PY_CHECK_TYPE(&epm_rhs_osi_tp4_Type, in, talloc_free(ret); return NULL;);
    1407           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1408           0 :                                 PyErr_NoMemory();
    1409           0 :                                 talloc_free(ret); return NULL;
    1410             :                         }
    1411           0 :                         ret->osi_tp4 = *(struct epm_rhs_osi_tp4 *)pytalloc_get_ptr(in);
    1412           0 :                         break;
    1413             : 
    1414           0 :                 case EPM_PROTOCOL_OSI_CLNS:
    1415           0 :                         if (in == NULL) {
    1416           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->osi_clns");
    1417           0 :                                 talloc_free(ret); return NULL;
    1418             :                         }
    1419           0 :                         PY_CHECK_TYPE(&epm_rhs_osi_clns_Type, in, talloc_free(ret); return NULL;);
    1420           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1421           0 :                                 PyErr_NoMemory();
    1422           0 :                                 talloc_free(ret); return NULL;
    1423             :                         }
    1424           0 :                         ret->osi_clns = *(struct epm_rhs_osi_clns *)pytalloc_get_ptr(in);
    1425           0 :                         break;
    1426             : 
    1427           0 :                 case EPM_PROTOCOL_TCP:
    1428           0 :                         if (in == NULL) {
    1429           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->tcp");
    1430           0 :                                 talloc_free(ret); return NULL;
    1431             :                         }
    1432           0 :                         PY_CHECK_TYPE(&epm_rhs_tcp_Type, in, talloc_free(ret); return NULL;);
    1433           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1434           0 :                                 PyErr_NoMemory();
    1435           0 :                                 talloc_free(ret); return NULL;
    1436             :                         }
    1437           0 :                         ret->tcp = *(struct epm_rhs_tcp *)pytalloc_get_ptr(in);
    1438           0 :                         break;
    1439             : 
    1440           0 :                 case EPM_PROTOCOL_UDP:
    1441           0 :                         if (in == NULL) {
    1442           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->udp");
    1443           0 :                                 talloc_free(ret); return NULL;
    1444             :                         }
    1445           0 :                         PY_CHECK_TYPE(&epm_rhs_udp_Type, in, talloc_free(ret); return NULL;);
    1446           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1447           0 :                                 PyErr_NoMemory();
    1448           0 :                                 talloc_free(ret); return NULL;
    1449             :                         }
    1450           0 :                         ret->udp = *(struct epm_rhs_udp *)pytalloc_get_ptr(in);
    1451           0 :                         break;
    1452             : 
    1453           0 :                 case EPM_PROTOCOL_IP:
    1454           0 :                         if (in == NULL) {
    1455           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->ip");
    1456           0 :                                 talloc_free(ret); return NULL;
    1457             :                         }
    1458           0 :                         PY_CHECK_TYPE(&epm_rhs_ip_Type, in, talloc_free(ret); return NULL;);
    1459           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1460           0 :                                 PyErr_NoMemory();
    1461           0 :                                 talloc_free(ret); return NULL;
    1462             :                         }
    1463           0 :                         ret->ip = *(struct epm_rhs_ip *)pytalloc_get_ptr(in);
    1464           0 :                         break;
    1465             : 
    1466           0 :                 case EPM_PROTOCOL_NCADG:
    1467           0 :                         if (in == NULL) {
    1468           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->ncadg");
    1469           0 :                                 talloc_free(ret); return NULL;
    1470             :                         }
    1471           0 :                         PY_CHECK_TYPE(&epm_rhs_ncadg_Type, in, talloc_free(ret); return NULL;);
    1472           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1473           0 :                                 PyErr_NoMemory();
    1474           0 :                                 talloc_free(ret); return NULL;
    1475             :                         }
    1476           0 :                         ret->ncadg = *(struct epm_rhs_ncadg *)pytalloc_get_ptr(in);
    1477           0 :                         break;
    1478             : 
    1479           0 :                 case EPM_PROTOCOL_NCACN:
    1480           0 :                         if (in == NULL) {
    1481           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->ncacn");
    1482           0 :                                 talloc_free(ret); return NULL;
    1483             :                         }
    1484           0 :                         PY_CHECK_TYPE(&epm_rhs_ncacn_Type, in, talloc_free(ret); return NULL;);
    1485           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1486           0 :                                 PyErr_NoMemory();
    1487           0 :                                 talloc_free(ret); return NULL;
    1488             :                         }
    1489           0 :                         ret->ncacn = *(struct epm_rhs_ncacn *)pytalloc_get_ptr(in);
    1490           0 :                         break;
    1491             : 
    1492           0 :                 case EPM_PROTOCOL_NCALRPC:
    1493           0 :                         if (in == NULL) {
    1494           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->ncalrpc");
    1495           0 :                                 talloc_free(ret); return NULL;
    1496             :                         }
    1497           0 :                         PY_CHECK_TYPE(&epm_rhs_ncalrpc_Type, in, talloc_free(ret); return NULL;);
    1498           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1499           0 :                                 PyErr_NoMemory();
    1500           0 :                                 talloc_free(ret); return NULL;
    1501             :                         }
    1502           0 :                         ret->ncalrpc = *(struct epm_rhs_ncalrpc *)pytalloc_get_ptr(in);
    1503           0 :                         break;
    1504             : 
    1505          96 :                 case EPM_PROTOCOL_UUID:
    1506          96 :                         if (in == NULL) {
    1507           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->uuid");
    1508           0 :                                 talloc_free(ret); return NULL;
    1509             :                         }
    1510          96 :                         PY_CHECK_TYPE(&epm_rhs_uuid_Type, in, talloc_free(ret); return NULL;);
    1511          96 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1512           0 :                                 PyErr_NoMemory();
    1513           0 :                                 talloc_free(ret); return NULL;
    1514             :                         }
    1515          96 :                         ret->uuid = *(struct epm_rhs_uuid *)pytalloc_get_ptr(in);
    1516          96 :                         break;
    1517             : 
    1518           0 :                 case EPM_PROTOCOL_IPX:
    1519           0 :                         if (in == NULL) {
    1520           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->ipx");
    1521           0 :                                 talloc_free(ret); return NULL;
    1522             :                         }
    1523           0 :                         PY_CHECK_TYPE(&epm_rhs_ipx_Type, in, talloc_free(ret); return NULL;);
    1524           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1525           0 :                                 PyErr_NoMemory();
    1526           0 :                                 talloc_free(ret); return NULL;
    1527             :                         }
    1528           0 :                         ret->ipx = *(struct epm_rhs_ipx *)pytalloc_get_ptr(in);
    1529           0 :                         break;
    1530             : 
    1531           0 :                 case EPM_PROTOCOL_SMB:
    1532           0 :                         if (in == NULL) {
    1533           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->smb");
    1534           0 :                                 talloc_free(ret); return NULL;
    1535             :                         }
    1536           0 :                         PY_CHECK_TYPE(&epm_rhs_smb_Type, in, talloc_free(ret); return NULL;);
    1537           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1538           0 :                                 PyErr_NoMemory();
    1539           0 :                                 talloc_free(ret); return NULL;
    1540             :                         }
    1541           0 :                         ret->smb = *(struct epm_rhs_smb *)pytalloc_get_ptr(in);
    1542           0 :                         break;
    1543             : 
    1544           0 :                 case EPM_PROTOCOL_NAMED_PIPE:
    1545           0 :                         if (in == NULL) {
    1546           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->named_pipe");
    1547           0 :                                 talloc_free(ret); return NULL;
    1548             :                         }
    1549           0 :                         PY_CHECK_TYPE(&epm_rhs_named_pipe_Type, in, talloc_free(ret); return NULL;);
    1550           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1551           0 :                                 PyErr_NoMemory();
    1552           0 :                                 talloc_free(ret); return NULL;
    1553             :                         }
    1554           0 :                         ret->named_pipe = *(struct epm_rhs_named_pipe *)pytalloc_get_ptr(in);
    1555           0 :                         break;
    1556             : 
    1557           0 :                 case EPM_PROTOCOL_NETBIOS:
    1558           0 :                         if (in == NULL) {
    1559           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->netbios");
    1560           0 :                                 talloc_free(ret); return NULL;
    1561             :                         }
    1562           0 :                         PY_CHECK_TYPE(&epm_rhs_netbios_Type, in, talloc_free(ret); return NULL;);
    1563           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1564           0 :                                 PyErr_NoMemory();
    1565           0 :                                 talloc_free(ret); return NULL;
    1566             :                         }
    1567           0 :                         ret->netbios = *(struct epm_rhs_netbios *)pytalloc_get_ptr(in);
    1568           0 :                         break;
    1569             : 
    1570           0 :                 case EPM_PROTOCOL_NETBEUI:
    1571           0 :                         if (in == NULL) {
    1572           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->netbeui");
    1573           0 :                                 talloc_free(ret); return NULL;
    1574             :                         }
    1575           0 :                         PY_CHECK_TYPE(&epm_rhs_netbeui_Type, in, talloc_free(ret); return NULL;);
    1576           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1577           0 :                                 PyErr_NoMemory();
    1578           0 :                                 talloc_free(ret); return NULL;
    1579             :                         }
    1580           0 :                         ret->netbeui = *(struct epm_rhs_netbeui *)pytalloc_get_ptr(in);
    1581           0 :                         break;
    1582             : 
    1583           0 :                 case EPM_PROTOCOL_SPX:
    1584           0 :                         if (in == NULL) {
    1585           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->spx");
    1586           0 :                                 talloc_free(ret); return NULL;
    1587             :                         }
    1588           0 :                         PY_CHECK_TYPE(&epm_rhs_spx_Type, in, talloc_free(ret); return NULL;);
    1589           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1590           0 :                                 PyErr_NoMemory();
    1591           0 :                                 talloc_free(ret); return NULL;
    1592             :                         }
    1593           0 :                         ret->spx = *(struct epm_rhs_spx *)pytalloc_get_ptr(in);
    1594           0 :                         break;
    1595             : 
    1596           0 :                 case EPM_PROTOCOL_NB_IPX:
    1597           0 :                         if (in == NULL) {
    1598           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->nb_ipx");
    1599           0 :                                 talloc_free(ret); return NULL;
    1600             :                         }
    1601           0 :                         PY_CHECK_TYPE(&epm_rhs_nb_ipx_Type, in, talloc_free(ret); return NULL;);
    1602           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1603           0 :                                 PyErr_NoMemory();
    1604           0 :                                 talloc_free(ret); return NULL;
    1605             :                         }
    1606           0 :                         ret->nb_ipx = *(struct epm_rhs_nb_ipx *)pytalloc_get_ptr(in);
    1607           0 :                         break;
    1608             : 
    1609           0 :                 case EPM_PROTOCOL_DSP:
    1610           0 :                         if (in == NULL) {
    1611           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->atalk_stream");
    1612           0 :                                 talloc_free(ret); return NULL;
    1613             :                         }
    1614           0 :                         PY_CHECK_TYPE(&epm_rhs_atalk_stream_Type, in, talloc_free(ret); return NULL;);
    1615           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1616           0 :                                 PyErr_NoMemory();
    1617           0 :                                 talloc_free(ret); return NULL;
    1618             :                         }
    1619           0 :                         ret->atalk_stream = *(struct epm_rhs_atalk_stream *)pytalloc_get_ptr(in);
    1620           0 :                         break;
    1621             : 
    1622           0 :                 case EPM_PROTOCOL_DDP:
    1623           0 :                         if (in == NULL) {
    1624           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->atalk_datagram");
    1625           0 :                                 talloc_free(ret); return NULL;
    1626             :                         }
    1627           0 :                         PY_CHECK_TYPE(&epm_rhs_atalk_datagram_Type, in, talloc_free(ret); return NULL;);
    1628           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1629           0 :                                 PyErr_NoMemory();
    1630           0 :                                 talloc_free(ret); return NULL;
    1631             :                         }
    1632           0 :                         ret->atalk_datagram = *(struct epm_rhs_atalk_datagram *)pytalloc_get_ptr(in);
    1633           0 :                         break;
    1634             : 
    1635           0 :                 case EPM_PROTOCOL_APPLETALK:
    1636           0 :                         if (in == NULL) {
    1637           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->appletalk");
    1638           0 :                                 talloc_free(ret); return NULL;
    1639             :                         }
    1640           0 :                         PY_CHECK_TYPE(&epm_rhs_appletalk_Type, in, talloc_free(ret); return NULL;);
    1641           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1642           0 :                                 PyErr_NoMemory();
    1643           0 :                                 talloc_free(ret); return NULL;
    1644             :                         }
    1645           0 :                         ret->appletalk = *(struct epm_rhs_appletalk *)pytalloc_get_ptr(in);
    1646           0 :                         break;
    1647             : 
    1648           0 :                 case EPM_PROTOCOL_VINES_SPP:
    1649           0 :                         if (in == NULL) {
    1650           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->vines_spp");
    1651           0 :                                 talloc_free(ret); return NULL;
    1652             :                         }
    1653           0 :                         PY_CHECK_TYPE(&epm_rhs_vines_spp_Type, in, talloc_free(ret); return NULL;);
    1654           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1655           0 :                                 PyErr_NoMemory();
    1656           0 :                                 talloc_free(ret); return NULL;
    1657             :                         }
    1658           0 :                         ret->vines_spp = *(struct epm_rhs_vines_spp *)pytalloc_get_ptr(in);
    1659           0 :                         break;
    1660             : 
    1661           0 :                 case EPM_PROTOCOL_VINES_IPC:
    1662           0 :                         if (in == NULL) {
    1663           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->vines_ipc");
    1664           0 :                                 talloc_free(ret); return NULL;
    1665             :                         }
    1666           0 :                         PY_CHECK_TYPE(&epm_rhs_vines_ipc_Type, in, talloc_free(ret); return NULL;);
    1667           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1668           0 :                                 PyErr_NoMemory();
    1669           0 :                                 talloc_free(ret); return NULL;
    1670             :                         }
    1671           0 :                         ret->vines_ipc = *(struct epm_rhs_vines_ipc *)pytalloc_get_ptr(in);
    1672           0 :                         break;
    1673             : 
    1674           0 :                 case EPM_PROTOCOL_STREETTALK:
    1675           0 :                         if (in == NULL) {
    1676           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->streettalk");
    1677           0 :                                 talloc_free(ret); return NULL;
    1678             :                         }
    1679           0 :                         PY_CHECK_TYPE(&epm_rhs_streettalk_Type, in, talloc_free(ret); return NULL;);
    1680           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1681           0 :                                 PyErr_NoMemory();
    1682           0 :                                 talloc_free(ret); return NULL;
    1683             :                         }
    1684           0 :                         ret->streettalk = *(struct epm_rhs_streettalk *)pytalloc_get_ptr(in);
    1685           0 :                         break;
    1686             : 
    1687           0 :                 case EPM_PROTOCOL_HTTP:
    1688           0 :                         if (in == NULL) {
    1689           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->http");
    1690           0 :                                 talloc_free(ret); return NULL;
    1691             :                         }
    1692           0 :                         PY_CHECK_TYPE(&epm_rhs_http_Type, in, talloc_free(ret); return NULL;);
    1693           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1694           0 :                                 PyErr_NoMemory();
    1695           0 :                                 talloc_free(ret); return NULL;
    1696             :                         }
    1697           0 :                         ret->http = *(struct epm_rhs_http *)pytalloc_get_ptr(in);
    1698           0 :                         break;
    1699             : 
    1700           0 :                 case EPM_PROTOCOL_UNIX_DS:
    1701           0 :                         if (in == NULL) {
    1702           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->unix_ds");
    1703           0 :                                 talloc_free(ret); return NULL;
    1704             :                         }
    1705           0 :                         PY_CHECK_TYPE(&epm_rhs_unix_ds_Type, in, talloc_free(ret); return NULL;);
    1706           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1707           0 :                                 PyErr_NoMemory();
    1708           0 :                                 talloc_free(ret); return NULL;
    1709             :                         }
    1710           0 :                         ret->unix_ds = *(struct epm_rhs_unix_ds *)pytalloc_get_ptr(in);
    1711           0 :                         break;
    1712             : 
    1713           0 :                 case EPM_PROTOCOL_NULL:
    1714           0 :                         if (in == NULL) {
    1715           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->null");
    1716           0 :                                 talloc_free(ret); return NULL;
    1717             :                         }
    1718           0 :                         PY_CHECK_TYPE(&epm_rhs_null_Type, in, talloc_free(ret); return NULL;);
    1719           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1720           0 :                                 PyErr_NoMemory();
    1721           0 :                                 talloc_free(ret); return NULL;
    1722             :                         }
    1723           0 :                         ret->null = *(struct epm_rhs_null *)pytalloc_get_ptr(in);
    1724           0 :                         break;
    1725             : 
    1726           0 :                 default:
    1727           0 :                         if (in == NULL) {
    1728           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->unknown");
    1729           0 :                                 talloc_free(ret); return NULL;
    1730             :                         }
    1731           0 :                         ret->unknown = data_blob_talloc(mem_ctx, PyBytes_AS_STRING(in), PyBytes_GET_SIZE(in));
    1732           0 :                         break;
    1733             : 
    1734             :         }
    1735             : 
    1736          96 :         return ret;
    1737             : }
    1738             : 
    1739         160 : static PyObject *py_epm_rhs_import(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    1740             : {
    1741         160 :         const char * const kwnames[] = { "mem_ctx", "level", "in", NULL };
    1742         160 :         PyObject *mem_ctx_obj = NULL;
    1743         160 :         TALLOC_CTX *mem_ctx = NULL;
    1744         160 :         int level = 0;
    1745         160 :         PyObject *in_obj = NULL;
    1746         160 :         union epm_rhs *in = NULL;
    1747             : 
    1748         160 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OiO:import",
    1749             :                 discard_const_p(char *, kwnames),
    1750             :                 &mem_ctx_obj,
    1751             :                 &level,
    1752             :                 &in_obj)) {
    1753           0 :                 return NULL;
    1754             :         }
    1755         160 :         mem_ctx = pytalloc_get_ptr(mem_ctx_obj);
    1756         160 :         if (mem_ctx == NULL) {
    1757           0 :                 PyErr_SetString(PyExc_TypeError, "mem_ctx is NULL)!");
    1758           0 :                 return NULL;
    1759             :         }
    1760         160 :         in = (union epm_rhs *)pytalloc_get_ptr(in_obj);
    1761         160 :         if (in == NULL) {
    1762           0 :                 PyErr_Format(PyExc_TypeError, "in needs to be a pointer to union epm_rhs!");
    1763           0 :                 return NULL;
    1764             :         }
    1765             : 
    1766         160 :         return py_import_epm_rhs(mem_ctx, level, in);
    1767             : }
    1768             : 
    1769          96 : static PyObject *py_epm_rhs_export(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    1770             : {
    1771          96 :         const char * const kwnames[] = { "mem_ctx", "level", "in", NULL };
    1772          96 :         PyObject *mem_ctx_obj = NULL;
    1773          96 :         TALLOC_CTX *mem_ctx = NULL;
    1774          96 :         int level = 0;
    1775          96 :         PyObject *in = NULL;
    1776          96 :         union epm_rhs *out = NULL;
    1777             : 
    1778          96 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OiO:export",
    1779             :                 discard_const_p(char *, kwnames),
    1780             :                 &mem_ctx_obj,
    1781             :                 &level,
    1782             :                 &in)) {
    1783           0 :                 return NULL;
    1784             :         }
    1785          96 :         mem_ctx = pytalloc_get_ptr(mem_ctx_obj);
    1786          96 :         if (mem_ctx == NULL) {
    1787           0 :                 PyErr_SetString(PyExc_TypeError, "mem_ctx is NULL)!");
    1788           0 :                 return NULL;
    1789             :         }
    1790             : 
    1791          96 :         out = py_export_epm_rhs(mem_ctx, level, in);
    1792          96 :         if (out == NULL) {
    1793           0 :                 return NULL;
    1794             :         }
    1795             : 
    1796          96 :         return pytalloc_GenericObject_reference(out);
    1797             : }
    1798             : 
    1799             : static PyMethodDef py_epm_rhs_methods[] = {
    1800             :         { "__import__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_rhs_import),
    1801             :                 METH_VARARGS|METH_KEYWORDS|METH_CLASS,
    1802             :                 "T.__import__(mem_ctx, level, in) => ret." },
    1803             :         { "__export__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_rhs_export),
    1804             :                 METH_VARARGS|METH_KEYWORDS|METH_CLASS,
    1805             :                 "T.__export__(mem_ctx, level, in) => ret." },
    1806             :         { NULL, NULL, 0, NULL }
    1807             : };
    1808             : 
    1809           0 : static PyObject *py_epm_rhs_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    1810             : {
    1811           0 :         PyErr_Format(PyExc_TypeError, "New %s Objects are not supported", type->tp_name);
    1812           0 :         return NULL;
    1813             : }
    1814             : 
    1815             : 
    1816             : static PyTypeObject epm_rhs_Type = {
    1817             :         PyVarObject_HEAD_INIT(NULL, 0)
    1818             :         .tp_name = "epmapper.epm_rhs",
    1819             :         .tp_getset = NULL,
    1820             :         .tp_methods = py_epm_rhs_methods,
    1821             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    1822             :         .tp_new = py_epm_rhs_new,
    1823             : };
    1824             : 
    1825             : 
    1826          32 : static PyObject *py_epm_lhs_get_protocol(PyObject *obj, void *closure)
    1827             : {
    1828          32 :         struct epm_lhs *object = pytalloc_get_ptr(obj);
    1829           0 :         PyObject *py_protocol;
    1830          32 :         py_protocol = PyLong_FromLong((uint16_t)(object->protocol));
    1831          32 :         return py_protocol;
    1832             : }
    1833             : 
    1834         240 : static int py_epm_lhs_set_protocol(PyObject *py_obj, PyObject *value, void *closure)
    1835             : {
    1836         240 :         struct epm_lhs *object = pytalloc_get_ptr(py_obj);
    1837         240 :         if (value == NULL) {
    1838           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->protocol");
    1839           0 :                 return -1;
    1840             :         }
    1841             :         {
    1842         240 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->protocol));
    1843         240 :                 if (PyLong_Check(value)) {
    1844           0 :                         unsigned long long test_var;
    1845         240 :                         test_var = PyLong_AsUnsignedLongLong(value);
    1846         240 :                         if (PyErr_Occurred() != NULL) {
    1847           0 :                                 return -1;
    1848             :                         }
    1849         240 :                         if (test_var > uint_max) {
    1850           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    1851             :                                   PyLong_Type.tp_name, uint_max, test_var);
    1852           0 :                                 return -1;
    1853             :                         }
    1854         240 :                         object->protocol = test_var;
    1855             :                 } else {
    1856           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1857             :                           PyLong_Type.tp_name);
    1858           0 :                         return -1;
    1859             :                 }
    1860             :         }
    1861         240 :         return 0;
    1862             : }
    1863             : 
    1864           0 : static PyObject *py_epm_lhs_get_lhs_data(PyObject *obj, void *closure)
    1865             : {
    1866           0 :         struct epm_lhs *object = pytalloc_get_ptr(obj);
    1867           0 :         PyObject *py_lhs_data;
    1868           0 :         py_lhs_data = PyBytes_FromStringAndSize((char *)(object->lhs_data).data, (object->lhs_data).length);
    1869           0 :         return py_lhs_data;
    1870             : }
    1871             : 
    1872         240 : static int py_epm_lhs_set_lhs_data(PyObject *py_obj, PyObject *value, void *closure)
    1873             : {
    1874         240 :         struct epm_lhs *object = pytalloc_get_ptr(py_obj);
    1875         240 :         if (value == NULL) {
    1876           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->lhs_data");
    1877           0 :                 return -1;
    1878             :         }
    1879         240 :         object->lhs_data = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyBytes_AS_STRING(value), PyBytes_GET_SIZE(value));
    1880         240 :         return 0;
    1881             : }
    1882             : 
    1883             : static PyGetSetDef py_epm_lhs_getsetters[] = {
    1884             :         {
    1885             :                 .name = discard_const_p(char, "protocol"),
    1886             :                 .get = py_epm_lhs_get_protocol,
    1887             :                 .set = py_epm_lhs_set_protocol,
    1888             :                 .doc = discard_const_p(char, "PIDL-generated element of base type epm_protocol")
    1889             :         },
    1890             :         {
    1891             :                 .name = discard_const_p(char, "lhs_data"),
    1892             :                 .get = py_epm_lhs_get_lhs_data,
    1893             :                 .set = py_epm_lhs_set_lhs_data,
    1894             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DATA_BLOB")
    1895             :         },
    1896             :         { .name = NULL }
    1897             : };
    1898             : 
    1899         240 : static PyObject *py_epm_lhs_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    1900             : {
    1901         240 :         return pytalloc_new(struct epm_lhs, type);
    1902             : }
    1903             : 
    1904             : 
    1905             : static PyTypeObject epm_lhs_Type = {
    1906             :         PyVarObject_HEAD_INIT(NULL, 0)
    1907             :         .tp_name = "epmapper.epm_lhs",
    1908             :         .tp_getset = py_epm_lhs_getsetters,
    1909             :         .tp_methods = NULL,
    1910             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    1911             :         .tp_new = py_epm_lhs_new,
    1912             : };
    1913             : 
    1914             : 
    1915          32 : static PyObject *py_epm_floor_get_lhs(PyObject *obj, void *closure)
    1916             : {
    1917          32 :         struct epm_floor *object = pytalloc_get_ptr(obj);
    1918           0 :         PyObject *py_lhs;
    1919          32 :         py_lhs = pytalloc_reference_ex(&epm_lhs_Type, pytalloc_get_mem_ctx(obj), &object->lhs);
    1920          32 :         return py_lhs;
    1921             : }
    1922             : 
    1923         240 : static int py_epm_floor_set_lhs(PyObject *py_obj, PyObject *value, void *closure)
    1924             : {
    1925         240 :         struct epm_floor *object = pytalloc_get_ptr(py_obj);
    1926         240 :         if (value == NULL) {
    1927           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->lhs");
    1928           0 :                 return -1;
    1929             :         }
    1930         240 :         PY_CHECK_TYPE(&epm_lhs_Type, value, return -1;);
    1931         240 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    1932           0 :                 PyErr_NoMemory();
    1933           0 :                 return -1;
    1934             :         }
    1935         240 :         object->lhs = *(struct epm_lhs *)pytalloc_get_ptr(value);
    1936         240 :         return 0;
    1937             : }
    1938             : 
    1939         160 : static PyObject *py_epm_floor_get_rhs(PyObject *obj, void *closure)
    1940             : {
    1941         160 :         struct epm_floor *object = pytalloc_get_ptr(obj);
    1942           0 :         PyObject *py_rhs;
    1943         160 :         py_rhs = pyrpc_import_union(&epm_rhs_Type, pytalloc_get_mem_ctx(obj), object->lhs.protocol, &object->rhs, "union epm_rhs");
    1944         160 :         if (py_rhs == NULL) {
    1945           0 :                 return NULL;
    1946             :         }
    1947         160 :         return py_rhs;
    1948             : }
    1949             : 
    1950          96 : static int py_epm_floor_set_rhs(PyObject *py_obj, PyObject *value, void *closure)
    1951             : {
    1952          96 :         struct epm_floor *object = pytalloc_get_ptr(py_obj);
    1953          96 :         if (value == NULL) {
    1954           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->rhs");
    1955           0 :                 return -1;
    1956             :         }
    1957             :         {
    1958           0 :                 union epm_rhs *rhs_switch_1;
    1959          96 :                 rhs_switch_1 = (union epm_rhs *)pyrpc_export_union(&epm_rhs_Type, pytalloc_get_mem_ctx(py_obj), object->lhs.protocol, value, "union epm_rhs");
    1960          96 :                 if (rhs_switch_1 == NULL) {
    1961           0 :                         return -1;
    1962             :                 }
    1963          96 :                 object->rhs = *rhs_switch_1;
    1964             :         }
    1965          96 :         return 0;
    1966             : }
    1967             : 
    1968             : static PyGetSetDef py_epm_floor_getsetters[] = {
    1969             :         {
    1970             :                 .name = discard_const_p(char, "lhs"),
    1971             :                 .get = py_epm_floor_get_lhs,
    1972             :                 .set = py_epm_floor_set_lhs,
    1973             :                 .doc = discard_const_p(char, "PIDL-generated element of base type epm_lhs")
    1974             :         },
    1975             :         {
    1976             :                 .name = discard_const_p(char, "rhs"),
    1977             :                 .get = py_epm_floor_get_rhs,
    1978             :                 .set = py_epm_floor_set_rhs,
    1979             :                 .doc = discard_const_p(char, "PIDL-generated element of base type epm_rhs")
    1980             :         },
    1981             :         { .name = NULL }
    1982             : };
    1983             : 
    1984         240 : static PyObject *py_epm_floor_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    1985             : {
    1986         240 :         return pytalloc_new(struct epm_floor, type);
    1987             : }
    1988             : 
    1989             : 
    1990             : static PyTypeObject epm_floor_Type = {
    1991             :         PyVarObject_HEAD_INIT(NULL, 0)
    1992             :         .tp_name = "epmapper.epm_floor",
    1993             :         .tp_getset = py_epm_floor_getsetters,
    1994             :         .tp_methods = NULL,
    1995             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    1996             :         .tp_new = py_epm_floor_new,
    1997             : };
    1998             : 
    1999             : 
    2000          16 : static PyObject *py_epm_tower_get_num_floors(PyObject *obj, void *closure)
    2001             : {
    2002          16 :         struct epm_tower *object = pytalloc_get_ptr(obj);
    2003           0 :         PyObject *py_num_floors;
    2004          16 :         py_num_floors = PyLong_FromLong((uint16_t)(object->num_floors));
    2005          16 :         return py_num_floors;
    2006             : }
    2007             : 
    2008          48 : static int py_epm_tower_set_num_floors(PyObject *py_obj, PyObject *value, void *closure)
    2009             : {
    2010          48 :         struct epm_tower *object = pytalloc_get_ptr(py_obj);
    2011          48 :         if (value == NULL) {
    2012           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->num_floors");
    2013           0 :                 return -1;
    2014             :         }
    2015             :         {
    2016          48 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->num_floors));
    2017          48 :                 if (PyLong_Check(value)) {
    2018           0 :                         unsigned long long test_var;
    2019          48 :                         test_var = PyLong_AsUnsignedLongLong(value);
    2020          48 :                         if (PyErr_Occurred() != NULL) {
    2021           0 :                                 return -1;
    2022             :                         }
    2023          48 :                         if (test_var > uint_max) {
    2024           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2025             :                                   PyLong_Type.tp_name, uint_max, test_var);
    2026           0 :                                 return -1;
    2027             :                         }
    2028          48 :                         object->num_floors = test_var;
    2029             :                 } else {
    2030           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2031             :                           PyLong_Type.tp_name);
    2032           0 :                         return -1;
    2033             :                 }
    2034             :         }
    2035          48 :         return 0;
    2036             : }
    2037             : 
    2038          64 : static PyObject *py_epm_tower_get_floors(PyObject *obj, void *closure)
    2039             : {
    2040          64 :         struct epm_tower *object = pytalloc_get_ptr(obj);
    2041           0 :         PyObject *py_floors;
    2042          64 :         py_floors = PyList_New(object->num_floors);
    2043          64 :         if (py_floors == NULL) {
    2044           0 :                 return NULL;
    2045             :         }
    2046             :         {
    2047             :                 int floors_cntr_0;
    2048         384 :                 for (floors_cntr_0 = 0; floors_cntr_0 < (object->num_floors); floors_cntr_0++) {
    2049           0 :                         PyObject *py_floors_0;
    2050         320 :                         py_floors_0 = pytalloc_reference_ex(&epm_floor_Type, object->floors, &(object->floors)[floors_cntr_0]);
    2051         320 :                         PyList_SetItem(py_floors, floors_cntr_0, py_floors_0);
    2052             :                 }
    2053             :         }
    2054          64 :         return py_floors;
    2055             : }
    2056             : 
    2057          48 : static int py_epm_tower_set_floors(PyObject *py_obj, PyObject *value, void *closure)
    2058             : {
    2059          48 :         struct epm_tower *object = pytalloc_get_ptr(py_obj);
    2060          48 :         if (value == NULL) {
    2061           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->floors");
    2062           0 :                 return -1;
    2063             :         }
    2064          48 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
    2065             :         {
    2066           0 :                 int floors_cntr_0;
    2067          48 :                 object->floors = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->floors, PyList_GET_SIZE(value));
    2068          48 :                 if (!object->floors) { return -1; }
    2069          48 :                 talloc_set_name_const(object->floors, "ARRAY: object->floors");
    2070         288 :                 for (floors_cntr_0 = 0; floors_cntr_0 < PyList_GET_SIZE(value); floors_cntr_0++) {
    2071         240 :                         if (PyList_GET_ITEM(value, floors_cntr_0) == NULL) {
    2072           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->floors)[floors_cntr_0]");
    2073           0 :                                 return -1;
    2074             :                         }
    2075         240 :                         PY_CHECK_TYPE(&epm_floor_Type, PyList_GET_ITEM(value, floors_cntr_0), return -1;);
    2076         240 :                         if (talloc_reference(object->floors, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, floors_cntr_0))) == NULL) {
    2077           0 :                                 PyErr_NoMemory();
    2078           0 :                                 return -1;
    2079             :                         }
    2080         240 :                         (object->floors)[floors_cntr_0] = *(struct epm_floor *)pytalloc_get_ptr(PyList_GET_ITEM(value, floors_cntr_0));
    2081             :                 }
    2082             :         }
    2083          48 :         return 0;
    2084             : }
    2085             : 
    2086             : static PyGetSetDef py_epm_tower_getsetters[] = {
    2087             :         {
    2088             :                 .name = discard_const_p(char, "num_floors"),
    2089             :                 .get = py_epm_tower_get_num_floors,
    2090             :                 .set = py_epm_tower_set_num_floors,
    2091             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
    2092             :         },
    2093             :         {
    2094             :                 .name = discard_const_p(char, "floors"),
    2095             :                 .get = py_epm_tower_get_floors,
    2096             :                 .set = py_epm_tower_set_floors,
    2097             :                 .doc = discard_const_p(char, "PIDL-generated element of base type epm_floor")
    2098             :         },
    2099             :         { .name = NULL }
    2100             : };
    2101             : 
    2102          48 : static PyObject *py_epm_tower_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    2103             : {
    2104          48 :         return pytalloc_new(struct epm_tower, type);
    2105             : }
    2106             : 
    2107             : 
    2108             : static PyTypeObject epm_tower_Type = {
    2109             :         PyVarObject_HEAD_INIT(NULL, 0)
    2110             :         .tp_name = "epmapper.epm_tower",
    2111             :         .tp_getset = py_epm_tower_getsetters,
    2112             :         .tp_methods = NULL,
    2113             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    2114             :         .tp_new = py_epm_tower_new,
    2115             : };
    2116             : 
    2117             : 
    2118          16 : static PyObject *py_epm_twr_t_get_tower_length(PyObject *obj, void *closure)
    2119             : {
    2120          16 :         struct epm_twr_t *object = pytalloc_get_ptr(obj);
    2121           0 :         PyObject *py_tower_length;
    2122          16 :         py_tower_length = PyLong_FromUnsignedLongLong((uint32_t)(object->tower_length));
    2123          16 :         return py_tower_length;
    2124             : }
    2125             : 
    2126           0 : static int py_epm_twr_t_set_tower_length(PyObject *py_obj, PyObject *value, void *closure)
    2127             : {
    2128           0 :         struct epm_twr_t *object = pytalloc_get_ptr(py_obj);
    2129           0 :         if (value == NULL) {
    2130           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->tower_length");
    2131           0 :                 return -1;
    2132             :         }
    2133             :         {
    2134           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->tower_length));
    2135           0 :                 if (PyLong_Check(value)) {
    2136           0 :                         unsigned long long test_var;
    2137           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    2138           0 :                         if (PyErr_Occurred() != NULL) {
    2139           0 :                                 return -1;
    2140             :                         }
    2141           0 :                         if (test_var > uint_max) {
    2142           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2143             :                                   PyLong_Type.tp_name, uint_max, test_var);
    2144           0 :                                 return -1;
    2145             :                         }
    2146           0 :                         object->tower_length = test_var;
    2147             :                 } else {
    2148           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2149             :                           PyLong_Type.tp_name);
    2150           0 :                         return -1;
    2151             :                 }
    2152             :         }
    2153           0 :         return 0;
    2154             : }
    2155             : 
    2156          80 : static PyObject *py_epm_twr_t_get_tower(PyObject *obj, void *closure)
    2157             : {
    2158          80 :         struct epm_twr_t *object = pytalloc_get_ptr(obj);
    2159           0 :         PyObject *py_tower;
    2160          80 :         py_tower = pytalloc_reference_ex(&epm_tower_Type, pytalloc_get_mem_ctx(obj), &object->tower);
    2161          80 :         return py_tower;
    2162             : }
    2163             : 
    2164          48 : static int py_epm_twr_t_set_tower(PyObject *py_obj, PyObject *value, void *closure)
    2165             : {
    2166          48 :         struct epm_twr_t *object = pytalloc_get_ptr(py_obj);
    2167          48 :         if (value == NULL) {
    2168           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->tower");
    2169           0 :                 return -1;
    2170             :         }
    2171          48 :         PY_CHECK_TYPE(&epm_tower_Type, value, return -1;);
    2172          48 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    2173           0 :                 PyErr_NoMemory();
    2174           0 :                 return -1;
    2175             :         }
    2176          48 :         object->tower = *(struct epm_tower *)pytalloc_get_ptr(value);
    2177          48 :         return 0;
    2178             : }
    2179             : 
    2180             : static PyGetSetDef py_epm_twr_t_getsetters[] = {
    2181             :         {
    2182             :                 .name = discard_const_p(char, "tower_length"),
    2183             :                 .get = py_epm_twr_t_get_tower_length,
    2184             :                 .set = py_epm_twr_t_set_tower_length,
    2185             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    2186             :         },
    2187             :         {
    2188             :                 .name = discard_const_p(char, "tower"),
    2189             :                 .get = py_epm_twr_t_get_tower,
    2190             :                 .set = py_epm_twr_t_set_tower,
    2191             :                 .doc = discard_const_p(char, "PIDL-generated element of base type epm_tower")
    2192             :         },
    2193             :         { .name = NULL }
    2194             : };
    2195             : 
    2196          48 : static PyObject *py_epm_twr_t_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    2197             : {
    2198          48 :         return pytalloc_new(struct epm_twr_t, type);
    2199             : }
    2200             : 
    2201           0 : static PyObject *py_epm_twr_t_ndr_pack(PyObject *py_obj,  PyObject *Py_UNUSED(ignored))
    2202             : {
    2203           0 :         struct epm_twr_t *object = pytalloc_get_ptr(py_obj);
    2204           0 :         PyObject *ret = NULL;
    2205           0 :         DATA_BLOB blob;
    2206           0 :         enum ndr_err_code err;
    2207           0 :         TALLOC_CTX *tmp_ctx = talloc_new(pytalloc_get_mem_ctx(py_obj));
    2208           0 :         if (tmp_ctx == NULL) {
    2209           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    2210           0 :                 return NULL;
    2211             :         }
    2212           0 :         err = ndr_push_struct_blob(&blob, tmp_ctx, object, (ndr_push_flags_fn_t)ndr_push_epm_twr_t);
    2213           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    2214           0 :                 TALLOC_FREE(tmp_ctx);
    2215           0 :                 PyErr_SetNdrError(err);
    2216           0 :                 return NULL;
    2217             :         }
    2218             : 
    2219           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
    2220           0 :         TALLOC_FREE(tmp_ctx);
    2221           0 :         return ret;
    2222             : }
    2223             : 
    2224           0 : static PyObject *py_epm_twr_t_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    2225             : {
    2226           0 :         struct epm_twr_t *object = pytalloc_get_ptr(py_obj);
    2227           0 :         DATA_BLOB blob = {.data = NULL, .length = 0};
    2228           0 :         Py_ssize_t blob_length = 0;
    2229           0 :         enum ndr_err_code err;
    2230           0 :         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
    2231           0 :         PyObject *allow_remaining_obj = NULL;
    2232           0 :         bool allow_remaining = false;
    2233             : 
    2234           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|O:__ndr_unpack__",
    2235             :                 discard_const_p(char *, kwnames),
    2236             :                 &blob.data, &blob_length,
    2237             :                 &allow_remaining_obj)) {
    2238           0 :                 return NULL;
    2239             :         }
    2240           0 :         blob.length = blob_length;
    2241             : 
    2242           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    2243           0 :                 allow_remaining = true;
    2244             :         }
    2245             : 
    2246           0 :         if (allow_remaining) {
    2247           0 :                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_epm_twr_t);
    2248             :         } else {
    2249           0 :                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_epm_twr_t);
    2250             :         }
    2251           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    2252           0 :                 PyErr_SetNdrError(err);
    2253           0 :                 return NULL;
    2254             :         }
    2255             : 
    2256           0 :         Py_RETURN_NONE;
    2257             : }
    2258             : 
    2259           0 : static PyObject *py_epm_twr_t_ndr_print(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    2260             : {
    2261           0 :         struct epm_twr_t *object = pytalloc_get_ptr(py_obj);
    2262           0 :         PyObject *ret;
    2263           0 :         char *retstr;
    2264             : 
    2265           0 :         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_epm_twr_t, "epm_twr_t", object);
    2266           0 :         ret = PyUnicode_FromString(retstr);
    2267           0 :         talloc_free(retstr);
    2268             : 
    2269           0 :         return ret;
    2270             : }
    2271             : 
    2272             : static PyMethodDef py_epm_twr_t_methods[] = {
    2273             :         { "__ndr_pack__", (PyCFunction)py_epm_twr_t_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
    2274             :         { "__ndr_unpack__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_twr_t_ndr_unpack), METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
    2275             :         { "__ndr_print__", (PyCFunction)py_epm_twr_t_ndr_print, METH_NOARGS, "S.ndr_print(object) -> None\nNDR print" },
    2276             :         { NULL, NULL, 0, NULL }
    2277             : };
    2278             : 
    2279             : 
    2280             : static PyTypeObject epm_twr_t_Type = {
    2281             :         PyVarObject_HEAD_INIT(NULL, 0)
    2282             :         .tp_name = "epmapper.epm_twr_t",
    2283             :         .tp_getset = py_epm_twr_t_getsetters,
    2284             :         .tp_methods = py_epm_twr_t_methods,
    2285             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    2286             :         .tp_new = py_epm_twr_t_new,
    2287             : };
    2288             : 
    2289             : 
    2290           0 : static PyObject *py_epm_entry_t_get_object(PyObject *obj, void *closure)
    2291             : {
    2292           0 :         struct epm_entry_t *object = pytalloc_get_ptr(obj);
    2293           0 :         PyObject *py_object;
    2294           0 :         py_object = pytalloc_reference_ex(GUID_Type, pytalloc_get_mem_ctx(obj), &object->object);
    2295           0 :         return py_object;
    2296             : }
    2297             : 
    2298           0 : static int py_epm_entry_t_set_object(PyObject *py_obj, PyObject *value, void *closure)
    2299             : {
    2300           0 :         struct epm_entry_t *object = pytalloc_get_ptr(py_obj);
    2301           0 :         if (value == NULL) {
    2302           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->object");
    2303           0 :                 return -1;
    2304             :         }
    2305           0 :         PY_CHECK_TYPE(GUID_Type, value, return -1;);
    2306           0 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    2307           0 :                 PyErr_NoMemory();
    2308           0 :                 return -1;
    2309             :         }
    2310           0 :         object->object = *(struct GUID *)pytalloc_get_ptr(value);
    2311           0 :         return 0;
    2312             : }
    2313             : 
    2314           0 : static PyObject *py_epm_entry_t_get_tower(PyObject *obj, void *closure)
    2315             : {
    2316           0 :         struct epm_entry_t *object = pytalloc_get_ptr(obj);
    2317           0 :         PyObject *py_tower;
    2318           0 :         if (object->tower == NULL) {
    2319           0 :                 Py_RETURN_NONE;
    2320             :         }
    2321           0 :         if (object->tower == NULL) {
    2322           0 :                 py_tower = Py_None;
    2323           0 :                 Py_INCREF(py_tower);
    2324             :         } else {
    2325           0 :                 py_tower = pytalloc_reference_ex(&epm_twr_t_Type, object->tower, object->tower);
    2326             :         }
    2327           0 :         return py_tower;
    2328             : }
    2329             : 
    2330           0 : static int py_epm_entry_t_set_tower(PyObject *py_obj, PyObject *value, void *closure)
    2331             : {
    2332           0 :         struct epm_entry_t *object = pytalloc_get_ptr(py_obj);
    2333           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->tower));
    2334           0 :         if (value == NULL) {
    2335           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->tower");
    2336           0 :                 return -1;
    2337             :         }
    2338           0 :         if (value == Py_None) {
    2339           0 :                 object->tower = NULL;
    2340             :         } else {
    2341           0 :                 object->tower = NULL;
    2342           0 :                 PY_CHECK_TYPE(&epm_twr_t_Type, value, return -1;);
    2343           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    2344           0 :                         PyErr_NoMemory();
    2345           0 :                         return -1;
    2346             :                 }
    2347           0 :                 object->tower = (struct epm_twr_t *)pytalloc_get_ptr(value);
    2348             :         }
    2349           0 :         return 0;
    2350             : }
    2351             : 
    2352           0 : static PyObject *py_epm_entry_t_get___annotation_offset(PyObject *obj, void *closure)
    2353             : {
    2354           0 :         struct epm_entry_t *object = pytalloc_get_ptr(obj);
    2355           0 :         PyObject *py___annotation_offset;
    2356           0 :         py___annotation_offset = PyLong_FromUnsignedLongLong((uint32_t)(object->__annotation_offset));
    2357           0 :         return py___annotation_offset;
    2358             : }
    2359             : 
    2360           0 : static int py_epm_entry_t_set___annotation_offset(PyObject *py_obj, PyObject *value, void *closure)
    2361             : {
    2362           0 :         struct epm_entry_t *object = pytalloc_get_ptr(py_obj);
    2363           0 :         if (value == NULL) {
    2364           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->__annotation_offset");
    2365           0 :                 return -1;
    2366             :         }
    2367             :         {
    2368           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->__annotation_offset));
    2369           0 :                 if (PyLong_Check(value)) {
    2370           0 :                         unsigned long long test_var;
    2371           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    2372           0 :                         if (PyErr_Occurred() != NULL) {
    2373           0 :                                 return -1;
    2374             :                         }
    2375           0 :                         if (test_var > uint_max) {
    2376           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2377             :                                   PyLong_Type.tp_name, uint_max, test_var);
    2378           0 :                                 return -1;
    2379             :                         }
    2380           0 :                         object->__annotation_offset = test_var;
    2381             :                 } else {
    2382           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2383             :                           PyLong_Type.tp_name);
    2384           0 :                         return -1;
    2385             :                 }
    2386             :         }
    2387           0 :         return 0;
    2388             : }
    2389             : 
    2390           0 : static PyObject *py_epm_entry_t_get___annotation_length(PyObject *obj, void *closure)
    2391             : {
    2392           0 :         struct epm_entry_t *object = pytalloc_get_ptr(obj);
    2393           0 :         PyObject *py___annotation_length;
    2394           0 :         py___annotation_length = PyLong_FromUnsignedLongLong((uint32_t)(object->__annotation_length));
    2395           0 :         return py___annotation_length;
    2396             : }
    2397             : 
    2398           0 : static int py_epm_entry_t_set___annotation_length(PyObject *py_obj, PyObject *value, void *closure)
    2399             : {
    2400           0 :         struct epm_entry_t *object = pytalloc_get_ptr(py_obj);
    2401           0 :         if (value == NULL) {
    2402           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->__annotation_length");
    2403           0 :                 return -1;
    2404             :         }
    2405             :         {
    2406           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->__annotation_length));
    2407           0 :                 if (PyLong_Check(value)) {
    2408           0 :                         unsigned long long test_var;
    2409           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    2410           0 :                         if (PyErr_Occurred() != NULL) {
    2411           0 :                                 return -1;
    2412             :                         }
    2413           0 :                         if (test_var > uint_max) {
    2414           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2415             :                                   PyLong_Type.tp_name, uint_max, test_var);
    2416           0 :                                 return -1;
    2417             :                         }
    2418           0 :                         object->__annotation_length = test_var;
    2419             :                 } else {
    2420           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2421             :                           PyLong_Type.tp_name);
    2422           0 :                         return -1;
    2423             :                 }
    2424             :         }
    2425           0 :         return 0;
    2426             : }
    2427             : 
    2428           0 : static PyObject *py_epm_entry_t_get_annotation(PyObject *obj, void *closure)
    2429             : {
    2430           0 :         struct epm_entry_t *object = pytalloc_get_ptr(obj);
    2431           0 :         PyObject *py_annotation;
    2432           0 :         if (object->annotation == NULL) {
    2433           0 :                 py_annotation = Py_None;
    2434           0 :                 Py_INCREF(py_annotation);
    2435             :         } else {
    2436           0 :                 py_annotation = PyUnicode_Decode(object->annotation, strlen(object->annotation), "utf-8", "ignore");
    2437             :         }
    2438           0 :         return py_annotation;
    2439             : }
    2440             : 
    2441           0 : static int py_epm_entry_t_set_annotation(PyObject *py_obj, PyObject *value, void *closure)
    2442             : {
    2443           0 :         struct epm_entry_t *object = pytalloc_get_ptr(py_obj);
    2444           0 :         if (value == NULL) {
    2445           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->annotation");
    2446           0 :                 return -1;
    2447             :         }
    2448             :         {
    2449           0 :                 const char *test_str;
    2450           0 :                 const char *talloc_str;
    2451           0 :                 PyObject *unicode = NULL;
    2452           0 :                 if (PyUnicode_Check(value)) {
    2453           0 :                         unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    2454           0 :                         if (unicode == NULL) {
    2455           0 :                                 return -1;
    2456             :                         }
    2457           0 :                         test_str = PyBytes_AS_STRING(unicode);
    2458           0 :                 } else if (PyBytes_Check(value)) {
    2459           0 :                         test_str = PyBytes_AS_STRING(value);
    2460             :                 } else {
    2461           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    2462           0 :                         return -1;
    2463             :                 }
    2464           0 :                 talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    2465           0 :                 if (unicode != NULL) {
    2466           0 :                         Py_DECREF(unicode);
    2467             :                 }
    2468           0 :                 if (talloc_str == NULL) {
    2469           0 :                         PyErr_NoMemory();
    2470           0 :                         return -1;
    2471             :                 }
    2472           0 :                 object->annotation = talloc_str;
    2473             :         }
    2474           0 :         return 0;
    2475             : }
    2476             : 
    2477             : static PyGetSetDef py_epm_entry_t_getsetters[] = {
    2478             :         {
    2479             :                 .name = discard_const_p(char, "object"),
    2480             :                 .get = py_epm_entry_t_get_object,
    2481             :                 .set = py_epm_entry_t_set_object,
    2482             :                 .doc = discard_const_p(char, "PIDL-generated element of base type GUID")
    2483             :         },
    2484             :         {
    2485             :                 .name = discard_const_p(char, "tower"),
    2486             :                 .get = py_epm_entry_t_get_tower,
    2487             :                 .set = py_epm_entry_t_set_tower,
    2488             :                 .doc = discard_const_p(char, "PIDL-generated element of base type epm_twr_t")
    2489             :         },
    2490             :         {
    2491             :                 .name = discard_const_p(char, "__annotation_offset"),
    2492             :                 .get = py_epm_entry_t_get___annotation_offset,
    2493             :                 .set = py_epm_entry_t_set___annotation_offset,
    2494             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    2495             :         },
    2496             :         {
    2497             :                 .name = discard_const_p(char, "__annotation_length"),
    2498             :                 .get = py_epm_entry_t_get___annotation_length,
    2499             :                 .set = py_epm_entry_t_set___annotation_length,
    2500             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    2501             :         },
    2502             :         {
    2503             :                 .name = discard_const_p(char, "annotation"),
    2504             :                 .get = py_epm_entry_t_get_annotation,
    2505             :                 .set = py_epm_entry_t_set_annotation,
    2506             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    2507             :         },
    2508             :         { .name = NULL }
    2509             : };
    2510             : 
    2511           0 : static PyObject *py_epm_entry_t_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    2512             : {
    2513           0 :         return pytalloc_new(struct epm_entry_t, type);
    2514             : }
    2515             : 
    2516             : 
    2517             : static PyTypeObject epm_entry_t_Type = {
    2518             :         PyVarObject_HEAD_INIT(NULL, 0)
    2519             :         .tp_name = "epmapper.epm_entry_t",
    2520             :         .tp_getset = py_epm_entry_t_getsetters,
    2521             :         .tp_methods = NULL,
    2522             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    2523             :         .tp_new = py_epm_entry_t_new,
    2524             : };
    2525             : 
    2526             : 
    2527           0 : static PyObject *py_rpc_if_id_t_get_uuid(PyObject *obj, void *closure)
    2528             : {
    2529           0 :         struct rpc_if_id_t *object = pytalloc_get_ptr(obj);
    2530           0 :         PyObject *py_uuid;
    2531           0 :         py_uuid = pytalloc_reference_ex(GUID_Type, pytalloc_get_mem_ctx(obj), &object->uuid);
    2532           0 :         return py_uuid;
    2533             : }
    2534             : 
    2535           0 : static int py_rpc_if_id_t_set_uuid(PyObject *py_obj, PyObject *value, void *closure)
    2536             : {
    2537           0 :         struct rpc_if_id_t *object = pytalloc_get_ptr(py_obj);
    2538           0 :         if (value == NULL) {
    2539           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->uuid");
    2540           0 :                 return -1;
    2541             :         }
    2542           0 :         PY_CHECK_TYPE(GUID_Type, value, return -1;);
    2543           0 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    2544           0 :                 PyErr_NoMemory();
    2545           0 :                 return -1;
    2546             :         }
    2547           0 :         object->uuid = *(struct GUID *)pytalloc_get_ptr(value);
    2548           0 :         return 0;
    2549             : }
    2550             : 
    2551           0 : static PyObject *py_rpc_if_id_t_get_vers_major(PyObject *obj, void *closure)
    2552             : {
    2553           0 :         struct rpc_if_id_t *object = pytalloc_get_ptr(obj);
    2554           0 :         PyObject *py_vers_major;
    2555           0 :         py_vers_major = PyLong_FromLong((uint16_t)(object->vers_major));
    2556           0 :         return py_vers_major;
    2557             : }
    2558             : 
    2559           0 : static int py_rpc_if_id_t_set_vers_major(PyObject *py_obj, PyObject *value, void *closure)
    2560             : {
    2561           0 :         struct rpc_if_id_t *object = pytalloc_get_ptr(py_obj);
    2562           0 :         if (value == NULL) {
    2563           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->vers_major");
    2564           0 :                 return -1;
    2565             :         }
    2566             :         {
    2567           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->vers_major));
    2568           0 :                 if (PyLong_Check(value)) {
    2569           0 :                         unsigned long long test_var;
    2570           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    2571           0 :                         if (PyErr_Occurred() != NULL) {
    2572           0 :                                 return -1;
    2573             :                         }
    2574           0 :                         if (test_var > uint_max) {
    2575           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2576             :                                   PyLong_Type.tp_name, uint_max, test_var);
    2577           0 :                                 return -1;
    2578             :                         }
    2579           0 :                         object->vers_major = test_var;
    2580             :                 } else {
    2581           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2582             :                           PyLong_Type.tp_name);
    2583           0 :                         return -1;
    2584             :                 }
    2585             :         }
    2586           0 :         return 0;
    2587             : }
    2588             : 
    2589           0 : static PyObject *py_rpc_if_id_t_get_vers_minor(PyObject *obj, void *closure)
    2590             : {
    2591           0 :         struct rpc_if_id_t *object = pytalloc_get_ptr(obj);
    2592           0 :         PyObject *py_vers_minor;
    2593           0 :         py_vers_minor = PyLong_FromLong((uint16_t)(object->vers_minor));
    2594           0 :         return py_vers_minor;
    2595             : }
    2596             : 
    2597           0 : static int py_rpc_if_id_t_set_vers_minor(PyObject *py_obj, PyObject *value, void *closure)
    2598             : {
    2599           0 :         struct rpc_if_id_t *object = pytalloc_get_ptr(py_obj);
    2600           0 :         if (value == NULL) {
    2601           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->vers_minor");
    2602           0 :                 return -1;
    2603             :         }
    2604             :         {
    2605           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->vers_minor));
    2606           0 :                 if (PyLong_Check(value)) {
    2607           0 :                         unsigned long long test_var;
    2608           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    2609           0 :                         if (PyErr_Occurred() != NULL) {
    2610           0 :                                 return -1;
    2611             :                         }
    2612           0 :                         if (test_var > uint_max) {
    2613           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2614             :                                   PyLong_Type.tp_name, uint_max, test_var);
    2615           0 :                                 return -1;
    2616             :                         }
    2617           0 :                         object->vers_minor = test_var;
    2618             :                 } else {
    2619           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2620             :                           PyLong_Type.tp_name);
    2621           0 :                         return -1;
    2622             :                 }
    2623             :         }
    2624           0 :         return 0;
    2625             : }
    2626             : 
    2627             : static PyGetSetDef py_rpc_if_id_t_getsetters[] = {
    2628             :         {
    2629             :                 .name = discard_const_p(char, "uuid"),
    2630             :                 .get = py_rpc_if_id_t_get_uuid,
    2631             :                 .set = py_rpc_if_id_t_set_uuid,
    2632             :                 .doc = discard_const_p(char, "PIDL-generated element of base type GUID")
    2633             :         },
    2634             :         {
    2635             :                 .name = discard_const_p(char, "vers_major"),
    2636             :                 .get = py_rpc_if_id_t_get_vers_major,
    2637             :                 .set = py_rpc_if_id_t_set_vers_major,
    2638             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
    2639             :         },
    2640             :         {
    2641             :                 .name = discard_const_p(char, "vers_minor"),
    2642             :                 .get = py_rpc_if_id_t_get_vers_minor,
    2643             :                 .set = py_rpc_if_id_t_set_vers_minor,
    2644             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
    2645             :         },
    2646             :         { .name = NULL }
    2647             : };
    2648             : 
    2649           0 : static PyObject *py_rpc_if_id_t_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    2650             : {
    2651           0 :         return pytalloc_new(struct rpc_if_id_t, type);
    2652             : }
    2653             : 
    2654             : 
    2655             : static PyTypeObject rpc_if_id_t_Type = {
    2656             :         PyVarObject_HEAD_INIT(NULL, 0)
    2657             :         .tp_name = "epmapper.rpc_if_id_t",
    2658             :         .tp_getset = py_rpc_if_id_t_getsetters,
    2659             :         .tp_methods = NULL,
    2660             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    2661             :         .tp_new = py_rpc_if_id_t_new,
    2662             : };
    2663             : 
    2664             : 
    2665          16 : static PyObject *py_epm_twr_p_t_get_twr(PyObject *obj, void *closure)
    2666             : {
    2667          16 :         struct epm_twr_p_t *object = pytalloc_get_ptr(obj);
    2668           0 :         PyObject *py_twr;
    2669          16 :         if (object->twr == NULL) {
    2670           0 :                 Py_RETURN_NONE;
    2671             :         }
    2672          16 :         if (object->twr == NULL) {
    2673           0 :                 py_twr = Py_None;
    2674           0 :                 Py_INCREF(py_twr);
    2675             :         } else {
    2676          16 :                 py_twr = pytalloc_reference_ex(&epm_twr_t_Type, object->twr, object->twr);
    2677             :         }
    2678          16 :         return py_twr;
    2679             : }
    2680             : 
    2681           0 : static int py_epm_twr_p_t_set_twr(PyObject *py_obj, PyObject *value, void *closure)
    2682             : {
    2683           0 :         struct epm_twr_p_t *object = pytalloc_get_ptr(py_obj);
    2684           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->twr));
    2685           0 :         if (value == NULL) {
    2686           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->twr");
    2687           0 :                 return -1;
    2688             :         }
    2689           0 :         if (value == Py_None) {
    2690           0 :                 object->twr = NULL;
    2691             :         } else {
    2692           0 :                 object->twr = NULL;
    2693           0 :                 PY_CHECK_TYPE(&epm_twr_t_Type, value, return -1;);
    2694           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    2695           0 :                         PyErr_NoMemory();
    2696           0 :                         return -1;
    2697             :                 }
    2698           0 :                 object->twr = (struct epm_twr_t *)pytalloc_get_ptr(value);
    2699             :         }
    2700           0 :         return 0;
    2701             : }
    2702             : 
    2703             : static PyGetSetDef py_epm_twr_p_t_getsetters[] = {
    2704             :         {
    2705             :                 .name = discard_const_p(char, "twr"),
    2706             :                 .get = py_epm_twr_p_t_get_twr,
    2707             :                 .set = py_epm_twr_p_t_set_twr,
    2708             :                 .doc = discard_const_p(char, "PIDL-generated element of base type epm_twr_t")
    2709             :         },
    2710             :         { .name = NULL }
    2711             : };
    2712             : 
    2713           0 : static PyObject *py_epm_twr_p_t_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    2714             : {
    2715           0 :         return pytalloc_new(struct epm_twr_p_t, type);
    2716             : }
    2717             : 
    2718             : 
    2719             : static PyTypeObject epm_twr_p_t_Type = {
    2720             :         PyVarObject_HEAD_INIT(NULL, 0)
    2721             :         .tp_name = "epmapper.epm_twr_p_t",
    2722             :         .tp_getset = py_epm_twr_p_t_getsetters,
    2723             :         .tp_methods = NULL,
    2724             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    2725             :         .tp_new = py_epm_twr_p_t_new,
    2726             : };
    2727             : 
    2728             : 
    2729             : 
    2730           0 : static PyObject *py_epm_Insert_in_get_num_ents(PyObject *obj, void *closure)
    2731             : {
    2732           0 :         struct epm_Insert *object = pytalloc_get_ptr(obj);
    2733           0 :         PyObject *py_num_ents;
    2734           0 :         py_num_ents = PyLong_FromUnsignedLongLong((uint32_t)(object->in.num_ents));
    2735           0 :         return py_num_ents;
    2736             : }
    2737             : 
    2738           0 : static int py_epm_Insert_in_set_num_ents(PyObject *py_obj, PyObject *value, void *closure)
    2739             : {
    2740           0 :         struct epm_Insert *object = pytalloc_get_ptr(py_obj);
    2741           0 :         if (value == NULL) {
    2742           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.num_ents");
    2743           0 :                 return -1;
    2744             :         }
    2745             :         {
    2746           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.num_ents));
    2747           0 :                 if (PyLong_Check(value)) {
    2748           0 :                         unsigned long long test_var;
    2749           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    2750           0 :                         if (PyErr_Occurred() != NULL) {
    2751           0 :                                 return -1;
    2752             :                         }
    2753           0 :                         if (test_var > uint_max) {
    2754           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2755             :                                   PyLong_Type.tp_name, uint_max, test_var);
    2756           0 :                                 return -1;
    2757             :                         }
    2758           0 :                         object->in.num_ents = test_var;
    2759             :                 } else {
    2760           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2761             :                           PyLong_Type.tp_name);
    2762           0 :                         return -1;
    2763             :                 }
    2764             :         }
    2765           0 :         return 0;
    2766             : }
    2767             : 
    2768           0 : static PyObject *py_epm_Insert_in_get_entries(PyObject *obj, void *closure)
    2769             : {
    2770           0 :         struct epm_Insert *object = pytalloc_get_ptr(obj);
    2771           0 :         PyObject *py_entries;
    2772           0 :         py_entries = PyList_New(object->in.num_ents);
    2773           0 :         if (py_entries == NULL) {
    2774           0 :                 return NULL;
    2775             :         }
    2776             :         {
    2777             :                 int entries_cntr_0;
    2778           0 :                 for (entries_cntr_0 = 0; entries_cntr_0 < (object->in.num_ents); entries_cntr_0++) {
    2779           0 :                         PyObject *py_entries_0;
    2780           0 :                         py_entries_0 = pytalloc_reference_ex(&epm_entry_t_Type, object->in.entries, &(object->in.entries)[entries_cntr_0]);
    2781           0 :                         PyList_SetItem(py_entries, entries_cntr_0, py_entries_0);
    2782             :                 }
    2783             :         }
    2784           0 :         return py_entries;
    2785             : }
    2786             : 
    2787           0 : static int py_epm_Insert_in_set_entries(PyObject *py_obj, PyObject *value, void *closure)
    2788             : {
    2789           0 :         struct epm_Insert *object = pytalloc_get_ptr(py_obj);
    2790           0 :         if (value == NULL) {
    2791           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.entries");
    2792           0 :                 return -1;
    2793             :         }
    2794           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
    2795             :         {
    2796           0 :                 int entries_cntr_0;
    2797           0 :                 object->in.entries = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.entries, PyList_GET_SIZE(value));
    2798           0 :                 if (!object->in.entries) { return -1; }
    2799           0 :                 talloc_set_name_const(object->in.entries, "ARRAY: object->in.entries");
    2800           0 :                 for (entries_cntr_0 = 0; entries_cntr_0 < PyList_GET_SIZE(value); entries_cntr_0++) {
    2801           0 :                         if (PyList_GET_ITEM(value, entries_cntr_0) == NULL) {
    2802           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->in.entries)[entries_cntr_0]");
    2803           0 :                                 return -1;
    2804             :                         }
    2805           0 :                         PY_CHECK_TYPE(&epm_entry_t_Type, PyList_GET_ITEM(value, entries_cntr_0), return -1;);
    2806           0 :                         if (talloc_reference(object->in.entries, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, entries_cntr_0))) == NULL) {
    2807           0 :                                 PyErr_NoMemory();
    2808           0 :                                 return -1;
    2809             :                         }
    2810           0 :                         (object->in.entries)[entries_cntr_0] = *(struct epm_entry_t *)pytalloc_get_ptr(PyList_GET_ITEM(value, entries_cntr_0));
    2811             :                 }
    2812             :         }
    2813           0 :         return 0;
    2814             : }
    2815             : 
    2816           0 : static PyObject *py_epm_Insert_in_get_replace(PyObject *obj, void *closure)
    2817             : {
    2818           0 :         struct epm_Insert *object = pytalloc_get_ptr(obj);
    2819           0 :         PyObject *py_replace;
    2820           0 :         py_replace = PyLong_FromUnsignedLongLong((uint32_t)(object->in.replace));
    2821           0 :         return py_replace;
    2822             : }
    2823             : 
    2824           0 : static int py_epm_Insert_in_set_replace(PyObject *py_obj, PyObject *value, void *closure)
    2825             : {
    2826           0 :         struct epm_Insert *object = pytalloc_get_ptr(py_obj);
    2827           0 :         if (value == NULL) {
    2828           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.replace");
    2829           0 :                 return -1;
    2830             :         }
    2831             :         {
    2832           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.replace));
    2833           0 :                 if (PyLong_Check(value)) {
    2834           0 :                         unsigned long long test_var;
    2835           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    2836           0 :                         if (PyErr_Occurred() != NULL) {
    2837           0 :                                 return -1;
    2838             :                         }
    2839           0 :                         if (test_var > uint_max) {
    2840           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2841             :                                   PyLong_Type.tp_name, uint_max, test_var);
    2842           0 :                                 return -1;
    2843             :                         }
    2844           0 :                         object->in.replace = test_var;
    2845             :                 } else {
    2846           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2847             :                           PyLong_Type.tp_name);
    2848           0 :                         return -1;
    2849             :                 }
    2850             :         }
    2851           0 :         return 0;
    2852             : }
    2853             : 
    2854           0 : static PyObject *py_epm_Insert_get_result(PyObject *obj, void *closure)
    2855             : {
    2856           0 :         struct epm_Insert *object = pytalloc_get_ptr(obj);
    2857           0 :         PyObject *py_result;
    2858           0 :         py_result = PyLong_FromUnsignedLongLong((uint32_t)(object->out.result));
    2859           0 :         return py_result;
    2860             : }
    2861             : 
    2862           0 : static int py_epm_Insert_set_result(PyObject *py_obj, PyObject *value, void *closure)
    2863             : {
    2864           0 :         struct epm_Insert *object = pytalloc_get_ptr(py_obj);
    2865           0 :         if (value == NULL) {
    2866           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.result");
    2867           0 :                 return -1;
    2868             :         }
    2869             :         {
    2870           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->out.result));
    2871           0 :                 if (PyLong_Check(value)) {
    2872           0 :                         unsigned long long test_var;
    2873           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    2874           0 :                         if (PyErr_Occurred() != NULL) {
    2875           0 :                                 return -1;
    2876             :                         }
    2877           0 :                         if (test_var > uint_max) {
    2878           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2879             :                                   PyLong_Type.tp_name, uint_max, test_var);
    2880           0 :                                 return -1;
    2881             :                         }
    2882           0 :                         object->out.result = test_var;
    2883             :                 } else {
    2884           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2885             :                           PyLong_Type.tp_name);
    2886           0 :                         return -1;
    2887             :                 }
    2888             :         }
    2889           0 :         return 0;
    2890             : }
    2891             : 
    2892             : static PyGetSetDef py_epm_Insert_getsetters[] = {
    2893             :         {
    2894             :                 .name = discard_const_p(char, "in_num_ents"),
    2895             :                 .get = py_epm_Insert_in_get_num_ents,
    2896             :                 .set = py_epm_Insert_in_set_num_ents,
    2897             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    2898             :         },
    2899             :         {
    2900             :                 .name = discard_const_p(char, "in_entries"),
    2901             :                 .get = py_epm_Insert_in_get_entries,
    2902             :                 .set = py_epm_Insert_in_set_entries,
    2903             :                 .doc = discard_const_p(char, "PIDL-generated element of base type epm_entry_t")
    2904             :         },
    2905             :         {
    2906             :                 .name = discard_const_p(char, "in_replace"),
    2907             :                 .get = py_epm_Insert_in_get_replace,
    2908             :                 .set = py_epm_Insert_in_set_replace,
    2909             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    2910             :         },
    2911             :         {
    2912             :                 .name = discard_const_p(char, "result"),
    2913             :                 .get = py_epm_Insert_get_result,
    2914             :                 .set = py_epm_Insert_set_result,
    2915             :                 .doc = discard_const_p(char, "PIDL-generated element of type uint32")
    2916             :         },
    2917             :         { .name = NULL }
    2918             : };
    2919             : 
    2920           0 : static PyObject *py_epm_Insert_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    2921             : {
    2922           0 :         PyObject *self = pytalloc_new(struct epm_Insert, type);
    2923           0 :         return self;
    2924             : }
    2925             : 
    2926           0 : static PyObject *py_epm_Insert_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
    2927             : {
    2928             : 
    2929             : 
    2930           0 :         return PyLong_FromLong(0);
    2931             : }
    2932             : 
    2933           0 : static PyObject *py_epm_Insert_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
    2934             : {
    2935           0 :         const struct ndr_interface_call *call = NULL;
    2936           0 :         struct epm_Insert *object = pytalloc_get_ptr(py_obj);
    2937           0 :         PyObject *ret = NULL;
    2938           0 :         struct ndr_push *push = NULL;
    2939           0 :         DATA_BLOB blob;
    2940           0 :         enum ndr_err_code err;
    2941             : 
    2942           0 :         if (ndr_table_epmapper.num_calls < 1) {
    2943           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_epm_Insert_ndr_pack");
    2944           0 :                 return NULL;
    2945             :         }
    2946           0 :         call = &ndr_table_epmapper.calls[0];
    2947             : 
    2948           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
    2949           0 :         if (push == NULL) {
    2950           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    2951           0 :                 return NULL;
    2952             :         }
    2953             : 
    2954           0 :         push->flags |= ndr_push_flags;
    2955             : 
    2956           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
    2957           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    2958           0 :                 TALLOC_FREE(push);
    2959           0 :                 PyErr_SetNdrError(err);
    2960           0 :                 return NULL;
    2961             :         }
    2962           0 :         blob = ndr_push_blob(push);
    2963           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
    2964           0 :         TALLOC_FREE(push);
    2965           0 :         return ret;
    2966             : }
    2967             : 
    2968           0 : static PyObject *py_epm_Insert_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    2969             : {
    2970           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    2971           0 :         PyObject *bigendian_obj = NULL;
    2972           0 :         PyObject *ndr64_obj = NULL;
    2973           0 :         libndr_flags ndr_push_flags = 0;
    2974             : 
    2975           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
    2976             :                 discard_const_p(char *, kwnames),
    2977             :                 &bigendian_obj,
    2978             :                 &ndr64_obj)) {
    2979           0 :                 return NULL;
    2980             :         }
    2981             : 
    2982           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    2983           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    2984             :         }
    2985           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    2986           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    2987             :         }
    2988             : 
    2989           0 :         return py_epm_Insert_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
    2990             : }
    2991             : 
    2992           0 : static PyObject *py_epm_Insert_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    2993             : {
    2994           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    2995           0 :         PyObject *bigendian_obj = NULL;
    2996           0 :         PyObject *ndr64_obj = NULL;
    2997           0 :         libndr_flags ndr_push_flags = 0;
    2998             : 
    2999           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
    3000             :                 discard_const_p(char *, kwnames),
    3001             :                 &bigendian_obj,
    3002             :                 &ndr64_obj)) {
    3003           0 :                 return NULL;
    3004             :         }
    3005             : 
    3006           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    3007           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    3008             :         }
    3009           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    3010           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    3011             :         }
    3012             : 
    3013           0 :         return py_epm_Insert_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
    3014             : }
    3015             : 
    3016           0 : static PyObject *py_epm_Insert_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
    3017             : {
    3018           0 :         const struct ndr_interface_call *call = NULL;
    3019           0 :         struct epm_Insert *object = pytalloc_get_ptr(py_obj);
    3020           0 :         struct ndr_pull *pull = NULL;
    3021           0 :         enum ndr_err_code err;
    3022             : 
    3023           0 :         if (ndr_table_epmapper.num_calls < 1) {
    3024           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_epm_Insert_ndr_unpack");
    3025           0 :                 return NULL;
    3026             :         }
    3027           0 :         call = &ndr_table_epmapper.calls[0];
    3028             : 
    3029           0 :         pull = ndr_pull_init_blob(blob, object);
    3030           0 :         if (pull == NULL) {
    3031           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    3032           0 :                 return NULL;
    3033             :         }
    3034             : 
    3035           0 :         pull->flags |= ndr_pull_flags;
    3036             : 
    3037           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
    3038           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    3039           0 :                 TALLOC_FREE(pull);
    3040           0 :                 PyErr_SetNdrError(err);
    3041           0 :                 return NULL;
    3042             :         }
    3043           0 :         if (!allow_remaining) {
    3044           0 :                 uint32_t highest_ofs;
    3045             : 
    3046           0 :                 if (pull->offset > pull->relative_highest_offset) {
    3047           0 :                         highest_ofs = pull->offset;
    3048             :                 } else {
    3049           0 :                         highest_ofs = pull->relative_highest_offset;
    3050             :                 }
    3051           0 :                 if (highest_ofs < pull->data_size) {
    3052           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
    3053             :                                 "not all bytes consumed ofs[%u] size[%u]",
    3054             :                                 highest_ofs, pull->data_size);
    3055           0 :                         TALLOC_FREE(pull);
    3056           0 :                         PyErr_SetNdrError(err);
    3057           0 :                         return NULL;
    3058             :                 }
    3059             :         }
    3060             : 
    3061           0 :         TALLOC_FREE(pull);
    3062           0 :         Py_RETURN_NONE;
    3063             : }
    3064             : 
    3065           0 : static PyObject *py_epm_Insert_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    3066             : {
    3067           0 :         DATA_BLOB blob;
    3068           0 :         Py_ssize_t blob_length = 0;
    3069           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    3070           0 :         PyObject *bigendian_obj = NULL;
    3071           0 :         PyObject *ndr64_obj = NULL;
    3072           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    3073           0 :         PyObject *allow_remaining_obj = NULL;
    3074           0 :         bool allow_remaining = false;
    3075             : 
    3076           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
    3077             :                 discard_const_p(char *, kwnames),
    3078             :                 &blob.data, &blob_length,
    3079             :                 &bigendian_obj,
    3080             :                 &ndr64_obj,
    3081             :                 &allow_remaining_obj)) {
    3082           0 :                 return NULL;
    3083             :         }
    3084           0 :         blob.length = blob_length;
    3085             : 
    3086           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    3087           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    3088             :         }
    3089           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    3090           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    3091             :         }
    3092             : 
    3093           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    3094           0 :                 allow_remaining = true;
    3095             :         }
    3096             : 
    3097           0 :         return py_epm_Insert_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
    3098             : }
    3099             : 
    3100           0 : static PyObject *py_epm_Insert_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    3101             : {
    3102           0 :         DATA_BLOB blob;
    3103           0 :         Py_ssize_t blob_length = 0;
    3104           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    3105           0 :         PyObject *bigendian_obj = NULL;
    3106           0 :         PyObject *ndr64_obj = NULL;
    3107           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    3108           0 :         PyObject *allow_remaining_obj = NULL;
    3109           0 :         bool allow_remaining = false;
    3110             : 
    3111           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
    3112             :                 discard_const_p(char *, kwnames),
    3113             :                 &blob.data, &blob_length,
    3114             :                 &bigendian_obj,
    3115             :                 &ndr64_obj,
    3116             :                 &allow_remaining_obj)) {
    3117           0 :                 return NULL;
    3118             :         }
    3119           0 :         blob.length = blob_length;
    3120             : 
    3121           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    3122           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    3123             :         }
    3124           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    3125           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    3126             :         }
    3127             : 
    3128           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    3129           0 :                 allow_remaining = true;
    3130             :         }
    3131             : 
    3132           0 :         return py_epm_Insert_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
    3133             : }
    3134             : 
    3135           0 : static PyObject *py_epm_Insert_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
    3136             : {
    3137           0 :         const struct ndr_interface_call *call = NULL;
    3138           0 :         struct epm_Insert *object = pytalloc_get_ptr(py_obj);
    3139           0 :         PyObject *ret;
    3140           0 :         char *retstr;
    3141             : 
    3142           0 :         if (ndr_table_epmapper.num_calls < 1) {
    3143           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_epm_Insert_ndr_print");
    3144           0 :                 return NULL;
    3145             :         }
    3146           0 :         call = &ndr_table_epmapper.calls[0];
    3147             : 
    3148           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
    3149           0 :         ret = PyUnicode_FromString(retstr);
    3150           0 :         TALLOC_FREE(retstr);
    3151             : 
    3152           0 :         return ret;
    3153             : }
    3154             : 
    3155           0 : static PyObject *py_epm_Insert_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    3156             : {
    3157           0 :         return py_epm_Insert_ndr_print(py_obj, "epm_Insert_in", NDR_IN);
    3158             : }
    3159             : 
    3160           0 : static PyObject *py_epm_Insert_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    3161             : {
    3162           0 :         return py_epm_Insert_ndr_print(py_obj, "epm_Insert_out", NDR_OUT);
    3163             : }
    3164             : 
    3165             : static PyMethodDef py_epm_Insert_methods[] = {
    3166             :         { "opnum", (PyCFunction)py_epm_Insert_ndr_opnum, METH_NOARGS|METH_CLASS,
    3167             :                 "epmapper.epm_Insert.opnum() -> 0 (0x00) " },
    3168             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_Insert_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
    3169             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
    3170             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_Insert_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
    3171             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
    3172             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_Insert_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
    3173             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
    3174             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_Insert_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
    3175             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
    3176             :         { "__ndr_print_in__", (PyCFunction)py_epm_Insert_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
    3177             :         { "__ndr_print_out__", (PyCFunction)py_epm_Insert_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
    3178             :         { NULL, NULL, 0, NULL }
    3179             : };
    3180             : 
    3181             : 
    3182             : static PyTypeObject epm_Insert_Type = {
    3183             :         PyVarObject_HEAD_INIT(NULL, 0)
    3184             :         .tp_name = "epmapper.epm_Insert",
    3185             :         .tp_getset = py_epm_Insert_getsetters,
    3186             :         .tp_methods = py_epm_Insert_methods,
    3187             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    3188             :         .tp_new = py_epm_Insert_new,
    3189             : };
    3190             : 
    3191           0 : static bool pack_py_epm_Insert_args_in(PyObject *args, PyObject *kwargs, struct epm_Insert *r)
    3192             : {
    3193           0 :         PyObject *py_entries;
    3194           0 :         PyObject *py_replace;
    3195           0 :         const char *kwnames[] = {
    3196             :                 "entries", "replace", NULL
    3197             :         };
    3198             : 
    3199           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:epm_Insert", discard_const_p(char *, kwnames), &py_entries, &py_replace)) {
    3200           0 :                 return false;
    3201             :         }
    3202             : 
    3203           0 :         PY_CHECK_TYPE(&PyList_Type, py_entries, return false;);
    3204           0 :         r->in.num_ents = PyList_GET_SIZE(py_entries);
    3205           0 :         if (py_entries == NULL) {
    3206           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.entries");
    3207           0 :                 return false;
    3208             :         }
    3209           0 :         PY_CHECK_TYPE(&PyList_Type, py_entries, return false;);
    3210             :         {
    3211           0 :                 int entries_cntr_0;
    3212           0 :                 r->in.entries = talloc_array_ptrtype(r, r->in.entries, PyList_GET_SIZE(py_entries));
    3213           0 :                 if (!r->in.entries) { return false; }
    3214           0 :                 talloc_set_name_const(r->in.entries, "ARRAY: r->in.entries");
    3215           0 :                 for (entries_cntr_0 = 0; entries_cntr_0 < PyList_GET_SIZE(py_entries); entries_cntr_0++) {
    3216           0 :                         if (PyList_GET_ITEM(py_entries, entries_cntr_0) == NULL) {
    3217           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (r->in.entries)[entries_cntr_0]");
    3218           0 :                                 return false;
    3219             :                         }
    3220           0 :                         PY_CHECK_TYPE(&epm_entry_t_Type, PyList_GET_ITEM(py_entries, entries_cntr_0), return false;);
    3221           0 :                         if (talloc_reference(r->in.entries, pytalloc_get_mem_ctx(PyList_GET_ITEM(py_entries, entries_cntr_0))) == NULL) {
    3222           0 :                                 PyErr_NoMemory();
    3223           0 :                                 return false;
    3224             :                         }
    3225           0 :                         (r->in.entries)[entries_cntr_0] = *(struct epm_entry_t *)pytalloc_get_ptr(PyList_GET_ITEM(py_entries, entries_cntr_0));
    3226             :                 }
    3227             :         }
    3228           0 :         if (py_replace == NULL) {
    3229           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.replace");
    3230           0 :                 return false;
    3231             :         }
    3232             :         {
    3233           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.replace));
    3234           0 :                 if (PyLong_Check(py_replace)) {
    3235           0 :                         unsigned long long test_var;
    3236           0 :                         test_var = PyLong_AsUnsignedLongLong(py_replace);
    3237           0 :                         if (PyErr_Occurred() != NULL) {
    3238           0 :                                 return false;
    3239             :                         }
    3240           0 :                         if (test_var > uint_max) {
    3241           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3242             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3243           0 :                                 return false;
    3244             :                         }
    3245           0 :                         r->in.replace = test_var;
    3246             :                 } else {
    3247           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3248             :                           PyLong_Type.tp_name);
    3249           0 :                         return false;
    3250             :                 }
    3251             :         }
    3252           0 :         return true;
    3253             : }
    3254             : 
    3255           0 : static PyObject *unpack_py_epm_Insert_args_out(struct epm_Insert *r)
    3256             : {
    3257           0 :         PyObject *result;
    3258           0 :         result = PyLong_FromUnsignedLongLong((uint32_t)(r->out.result));
    3259           0 :         return result;
    3260             : }
    3261             : 
    3262             : 
    3263           0 : static PyObject *py_epm_Delete_in_get_num_ents(PyObject *obj, void *closure)
    3264             : {
    3265           0 :         struct epm_Delete *object = pytalloc_get_ptr(obj);
    3266           0 :         PyObject *py_num_ents;
    3267           0 :         py_num_ents = PyLong_FromUnsignedLongLong((uint32_t)(object->in.num_ents));
    3268           0 :         return py_num_ents;
    3269             : }
    3270             : 
    3271           0 : static int py_epm_Delete_in_set_num_ents(PyObject *py_obj, PyObject *value, void *closure)
    3272             : {
    3273           0 :         struct epm_Delete *object = pytalloc_get_ptr(py_obj);
    3274           0 :         if (value == NULL) {
    3275           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.num_ents");
    3276           0 :                 return -1;
    3277             :         }
    3278             :         {
    3279           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.num_ents));
    3280           0 :                 if (PyLong_Check(value)) {
    3281           0 :                         unsigned long long test_var;
    3282           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    3283           0 :                         if (PyErr_Occurred() != NULL) {
    3284           0 :                                 return -1;
    3285             :                         }
    3286           0 :                         if (test_var > uint_max) {
    3287           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3288             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3289           0 :                                 return -1;
    3290             :                         }
    3291           0 :                         object->in.num_ents = test_var;
    3292             :                 } else {
    3293           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3294             :                           PyLong_Type.tp_name);
    3295           0 :                         return -1;
    3296             :                 }
    3297             :         }
    3298           0 :         return 0;
    3299             : }
    3300             : 
    3301           0 : static PyObject *py_epm_Delete_in_get_entries(PyObject *obj, void *closure)
    3302             : {
    3303           0 :         struct epm_Delete *object = pytalloc_get_ptr(obj);
    3304           0 :         PyObject *py_entries;
    3305           0 :         py_entries = PyList_New(object->in.num_ents);
    3306           0 :         if (py_entries == NULL) {
    3307           0 :                 return NULL;
    3308             :         }
    3309             :         {
    3310             :                 int entries_cntr_0;
    3311           0 :                 for (entries_cntr_0 = 0; entries_cntr_0 < (object->in.num_ents); entries_cntr_0++) {
    3312           0 :                         PyObject *py_entries_0;
    3313           0 :                         py_entries_0 = pytalloc_reference_ex(&epm_entry_t_Type, object->in.entries, &(object->in.entries)[entries_cntr_0]);
    3314           0 :                         PyList_SetItem(py_entries, entries_cntr_0, py_entries_0);
    3315             :                 }
    3316             :         }
    3317           0 :         return py_entries;
    3318             : }
    3319             : 
    3320           0 : static int py_epm_Delete_in_set_entries(PyObject *py_obj, PyObject *value, void *closure)
    3321             : {
    3322           0 :         struct epm_Delete *object = pytalloc_get_ptr(py_obj);
    3323           0 :         if (value == NULL) {
    3324           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.entries");
    3325           0 :                 return -1;
    3326             :         }
    3327           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
    3328             :         {
    3329           0 :                 int entries_cntr_0;
    3330           0 :                 object->in.entries = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.entries, PyList_GET_SIZE(value));
    3331           0 :                 if (!object->in.entries) { return -1; }
    3332           0 :                 talloc_set_name_const(object->in.entries, "ARRAY: object->in.entries");
    3333           0 :                 for (entries_cntr_0 = 0; entries_cntr_0 < PyList_GET_SIZE(value); entries_cntr_0++) {
    3334           0 :                         if (PyList_GET_ITEM(value, entries_cntr_0) == NULL) {
    3335           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->in.entries)[entries_cntr_0]");
    3336           0 :                                 return -1;
    3337             :                         }
    3338           0 :                         PY_CHECK_TYPE(&epm_entry_t_Type, PyList_GET_ITEM(value, entries_cntr_0), return -1;);
    3339           0 :                         if (talloc_reference(object->in.entries, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, entries_cntr_0))) == NULL) {
    3340           0 :                                 PyErr_NoMemory();
    3341           0 :                                 return -1;
    3342             :                         }
    3343           0 :                         (object->in.entries)[entries_cntr_0] = *(struct epm_entry_t *)pytalloc_get_ptr(PyList_GET_ITEM(value, entries_cntr_0));
    3344             :                 }
    3345             :         }
    3346           0 :         return 0;
    3347             : }
    3348             : 
    3349           0 : static PyObject *py_epm_Delete_get_result(PyObject *obj, void *closure)
    3350             : {
    3351           0 :         struct epm_Delete *object = pytalloc_get_ptr(obj);
    3352           0 :         PyObject *py_result;
    3353           0 :         py_result = PyLong_FromUnsignedLongLong((uint32_t)(object->out.result));
    3354           0 :         return py_result;
    3355             : }
    3356             : 
    3357           0 : static int py_epm_Delete_set_result(PyObject *py_obj, PyObject *value, void *closure)
    3358             : {
    3359           0 :         struct epm_Delete *object = pytalloc_get_ptr(py_obj);
    3360           0 :         if (value == NULL) {
    3361           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.result");
    3362           0 :                 return -1;
    3363             :         }
    3364             :         {
    3365           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->out.result));
    3366           0 :                 if (PyLong_Check(value)) {
    3367           0 :                         unsigned long long test_var;
    3368           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    3369           0 :                         if (PyErr_Occurred() != NULL) {
    3370           0 :                                 return -1;
    3371             :                         }
    3372           0 :                         if (test_var > uint_max) {
    3373           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3374             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3375           0 :                                 return -1;
    3376             :                         }
    3377           0 :                         object->out.result = test_var;
    3378             :                 } else {
    3379           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3380             :                           PyLong_Type.tp_name);
    3381           0 :                         return -1;
    3382             :                 }
    3383             :         }
    3384           0 :         return 0;
    3385             : }
    3386             : 
    3387             : static PyGetSetDef py_epm_Delete_getsetters[] = {
    3388             :         {
    3389             :                 .name = discard_const_p(char, "in_num_ents"),
    3390             :                 .get = py_epm_Delete_in_get_num_ents,
    3391             :                 .set = py_epm_Delete_in_set_num_ents,
    3392             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    3393             :         },
    3394             :         {
    3395             :                 .name = discard_const_p(char, "in_entries"),
    3396             :                 .get = py_epm_Delete_in_get_entries,
    3397             :                 .set = py_epm_Delete_in_set_entries,
    3398             :                 .doc = discard_const_p(char, "PIDL-generated element of base type epm_entry_t")
    3399             :         },
    3400             :         {
    3401             :                 .name = discard_const_p(char, "result"),
    3402             :                 .get = py_epm_Delete_get_result,
    3403             :                 .set = py_epm_Delete_set_result,
    3404             :                 .doc = discard_const_p(char, "PIDL-generated element of type uint32")
    3405             :         },
    3406             :         { .name = NULL }
    3407             : };
    3408             : 
    3409           0 : static PyObject *py_epm_Delete_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    3410             : {
    3411           0 :         PyObject *self = pytalloc_new(struct epm_Delete, type);
    3412           0 :         return self;
    3413             : }
    3414             : 
    3415           0 : static PyObject *py_epm_Delete_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
    3416             : {
    3417             : 
    3418             : 
    3419           0 :         return PyLong_FromLong(1);
    3420             : }
    3421             : 
    3422           0 : static PyObject *py_epm_Delete_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
    3423             : {
    3424           0 :         const struct ndr_interface_call *call = NULL;
    3425           0 :         struct epm_Delete *object = pytalloc_get_ptr(py_obj);
    3426           0 :         PyObject *ret = NULL;
    3427           0 :         struct ndr_push *push = NULL;
    3428           0 :         DATA_BLOB blob;
    3429           0 :         enum ndr_err_code err;
    3430             : 
    3431           0 :         if (ndr_table_epmapper.num_calls < 2) {
    3432           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_epm_Delete_ndr_pack");
    3433           0 :                 return NULL;
    3434             :         }
    3435           0 :         call = &ndr_table_epmapper.calls[1];
    3436             : 
    3437           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
    3438           0 :         if (push == NULL) {
    3439           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    3440           0 :                 return NULL;
    3441             :         }
    3442             : 
    3443           0 :         push->flags |= ndr_push_flags;
    3444             : 
    3445           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
    3446           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    3447           0 :                 TALLOC_FREE(push);
    3448           0 :                 PyErr_SetNdrError(err);
    3449           0 :                 return NULL;
    3450             :         }
    3451           0 :         blob = ndr_push_blob(push);
    3452           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
    3453           0 :         TALLOC_FREE(push);
    3454           0 :         return ret;
    3455             : }
    3456             : 
    3457           0 : static PyObject *py_epm_Delete_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    3458             : {
    3459           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    3460           0 :         PyObject *bigendian_obj = NULL;
    3461           0 :         PyObject *ndr64_obj = NULL;
    3462           0 :         libndr_flags ndr_push_flags = 0;
    3463             : 
    3464           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
    3465             :                 discard_const_p(char *, kwnames),
    3466             :                 &bigendian_obj,
    3467             :                 &ndr64_obj)) {
    3468           0 :                 return NULL;
    3469             :         }
    3470             : 
    3471           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    3472           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    3473             :         }
    3474           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    3475           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    3476             :         }
    3477             : 
    3478           0 :         return py_epm_Delete_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
    3479             : }
    3480             : 
    3481           0 : static PyObject *py_epm_Delete_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    3482             : {
    3483           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    3484           0 :         PyObject *bigendian_obj = NULL;
    3485           0 :         PyObject *ndr64_obj = NULL;
    3486           0 :         libndr_flags ndr_push_flags = 0;
    3487             : 
    3488           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
    3489             :                 discard_const_p(char *, kwnames),
    3490             :                 &bigendian_obj,
    3491             :                 &ndr64_obj)) {
    3492           0 :                 return NULL;
    3493             :         }
    3494             : 
    3495           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    3496           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    3497             :         }
    3498           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    3499           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    3500             :         }
    3501             : 
    3502           0 :         return py_epm_Delete_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
    3503             : }
    3504             : 
    3505           0 : static PyObject *py_epm_Delete_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
    3506             : {
    3507           0 :         const struct ndr_interface_call *call = NULL;
    3508           0 :         struct epm_Delete *object = pytalloc_get_ptr(py_obj);
    3509           0 :         struct ndr_pull *pull = NULL;
    3510           0 :         enum ndr_err_code err;
    3511             : 
    3512           0 :         if (ndr_table_epmapper.num_calls < 2) {
    3513           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_epm_Delete_ndr_unpack");
    3514           0 :                 return NULL;
    3515             :         }
    3516           0 :         call = &ndr_table_epmapper.calls[1];
    3517             : 
    3518           0 :         pull = ndr_pull_init_blob(blob, object);
    3519           0 :         if (pull == NULL) {
    3520           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    3521           0 :                 return NULL;
    3522             :         }
    3523             : 
    3524           0 :         pull->flags |= ndr_pull_flags;
    3525             : 
    3526           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
    3527           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    3528           0 :                 TALLOC_FREE(pull);
    3529           0 :                 PyErr_SetNdrError(err);
    3530           0 :                 return NULL;
    3531             :         }
    3532           0 :         if (!allow_remaining) {
    3533           0 :                 uint32_t highest_ofs;
    3534             : 
    3535           0 :                 if (pull->offset > pull->relative_highest_offset) {
    3536           0 :                         highest_ofs = pull->offset;
    3537             :                 } else {
    3538           0 :                         highest_ofs = pull->relative_highest_offset;
    3539             :                 }
    3540           0 :                 if (highest_ofs < pull->data_size) {
    3541           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
    3542             :                                 "not all bytes consumed ofs[%u] size[%u]",
    3543             :                                 highest_ofs, pull->data_size);
    3544           0 :                         TALLOC_FREE(pull);
    3545           0 :                         PyErr_SetNdrError(err);
    3546           0 :                         return NULL;
    3547             :                 }
    3548             :         }
    3549             : 
    3550           0 :         TALLOC_FREE(pull);
    3551           0 :         Py_RETURN_NONE;
    3552             : }
    3553             : 
    3554           0 : static PyObject *py_epm_Delete_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    3555             : {
    3556           0 :         DATA_BLOB blob;
    3557           0 :         Py_ssize_t blob_length = 0;
    3558           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    3559           0 :         PyObject *bigendian_obj = NULL;
    3560           0 :         PyObject *ndr64_obj = NULL;
    3561           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    3562           0 :         PyObject *allow_remaining_obj = NULL;
    3563           0 :         bool allow_remaining = false;
    3564             : 
    3565           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
    3566             :                 discard_const_p(char *, kwnames),
    3567             :                 &blob.data, &blob_length,
    3568             :                 &bigendian_obj,
    3569             :                 &ndr64_obj,
    3570             :                 &allow_remaining_obj)) {
    3571           0 :                 return NULL;
    3572             :         }
    3573           0 :         blob.length = blob_length;
    3574             : 
    3575           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    3576           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    3577             :         }
    3578           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    3579           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    3580             :         }
    3581             : 
    3582           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    3583           0 :                 allow_remaining = true;
    3584             :         }
    3585             : 
    3586           0 :         return py_epm_Delete_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
    3587             : }
    3588             : 
    3589           0 : static PyObject *py_epm_Delete_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    3590             : {
    3591           0 :         DATA_BLOB blob;
    3592           0 :         Py_ssize_t blob_length = 0;
    3593           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    3594           0 :         PyObject *bigendian_obj = NULL;
    3595           0 :         PyObject *ndr64_obj = NULL;
    3596           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    3597           0 :         PyObject *allow_remaining_obj = NULL;
    3598           0 :         bool allow_remaining = false;
    3599             : 
    3600           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
    3601             :                 discard_const_p(char *, kwnames),
    3602             :                 &blob.data, &blob_length,
    3603             :                 &bigendian_obj,
    3604             :                 &ndr64_obj,
    3605             :                 &allow_remaining_obj)) {
    3606           0 :                 return NULL;
    3607             :         }
    3608           0 :         blob.length = blob_length;
    3609             : 
    3610           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    3611           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    3612             :         }
    3613           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    3614           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    3615             :         }
    3616             : 
    3617           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    3618           0 :                 allow_remaining = true;
    3619             :         }
    3620             : 
    3621           0 :         return py_epm_Delete_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
    3622             : }
    3623             : 
    3624           0 : static PyObject *py_epm_Delete_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
    3625             : {
    3626           0 :         const struct ndr_interface_call *call = NULL;
    3627           0 :         struct epm_Delete *object = pytalloc_get_ptr(py_obj);
    3628           0 :         PyObject *ret;
    3629           0 :         char *retstr;
    3630             : 
    3631           0 :         if (ndr_table_epmapper.num_calls < 2) {
    3632           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_epm_Delete_ndr_print");
    3633           0 :                 return NULL;
    3634             :         }
    3635           0 :         call = &ndr_table_epmapper.calls[1];
    3636             : 
    3637           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
    3638           0 :         ret = PyUnicode_FromString(retstr);
    3639           0 :         TALLOC_FREE(retstr);
    3640             : 
    3641           0 :         return ret;
    3642             : }
    3643             : 
    3644           0 : static PyObject *py_epm_Delete_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    3645             : {
    3646           0 :         return py_epm_Delete_ndr_print(py_obj, "epm_Delete_in", NDR_IN);
    3647             : }
    3648             : 
    3649           0 : static PyObject *py_epm_Delete_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    3650             : {
    3651           0 :         return py_epm_Delete_ndr_print(py_obj, "epm_Delete_out", NDR_OUT);
    3652             : }
    3653             : 
    3654             : static PyMethodDef py_epm_Delete_methods[] = {
    3655             :         { "opnum", (PyCFunction)py_epm_Delete_ndr_opnum, METH_NOARGS|METH_CLASS,
    3656             :                 "epmapper.epm_Delete.opnum() -> 1 (0x01) " },
    3657             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_Delete_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
    3658             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
    3659             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_Delete_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
    3660             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
    3661             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_Delete_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
    3662             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
    3663             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_Delete_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
    3664             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
    3665             :         { "__ndr_print_in__", (PyCFunction)py_epm_Delete_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
    3666             :         { "__ndr_print_out__", (PyCFunction)py_epm_Delete_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
    3667             :         { NULL, NULL, 0, NULL }
    3668             : };
    3669             : 
    3670             : 
    3671             : static PyTypeObject epm_Delete_Type = {
    3672             :         PyVarObject_HEAD_INIT(NULL, 0)
    3673             :         .tp_name = "epmapper.epm_Delete",
    3674             :         .tp_getset = py_epm_Delete_getsetters,
    3675             :         .tp_methods = py_epm_Delete_methods,
    3676             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    3677             :         .tp_new = py_epm_Delete_new,
    3678             : };
    3679             : 
    3680           0 : static bool pack_py_epm_Delete_args_in(PyObject *args, PyObject *kwargs, struct epm_Delete *r)
    3681             : {
    3682           0 :         PyObject *py_entries;
    3683           0 :         const char *kwnames[] = {
    3684             :                 "entries", NULL
    3685             :         };
    3686             : 
    3687           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:epm_Delete", discard_const_p(char *, kwnames), &py_entries)) {
    3688           0 :                 return false;
    3689             :         }
    3690             : 
    3691           0 :         PY_CHECK_TYPE(&PyList_Type, py_entries, return false;);
    3692           0 :         r->in.num_ents = PyList_GET_SIZE(py_entries);
    3693           0 :         if (py_entries == NULL) {
    3694           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.entries");
    3695           0 :                 return false;
    3696             :         }
    3697           0 :         PY_CHECK_TYPE(&PyList_Type, py_entries, return false;);
    3698             :         {
    3699           0 :                 int entries_cntr_0;
    3700           0 :                 r->in.entries = talloc_array_ptrtype(r, r->in.entries, PyList_GET_SIZE(py_entries));
    3701           0 :                 if (!r->in.entries) { return false; }
    3702           0 :                 talloc_set_name_const(r->in.entries, "ARRAY: r->in.entries");
    3703           0 :                 for (entries_cntr_0 = 0; entries_cntr_0 < PyList_GET_SIZE(py_entries); entries_cntr_0++) {
    3704           0 :                         if (PyList_GET_ITEM(py_entries, entries_cntr_0) == NULL) {
    3705           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (r->in.entries)[entries_cntr_0]");
    3706           0 :                                 return false;
    3707             :                         }
    3708           0 :                         PY_CHECK_TYPE(&epm_entry_t_Type, PyList_GET_ITEM(py_entries, entries_cntr_0), return false;);
    3709           0 :                         if (talloc_reference(r->in.entries, pytalloc_get_mem_ctx(PyList_GET_ITEM(py_entries, entries_cntr_0))) == NULL) {
    3710           0 :                                 PyErr_NoMemory();
    3711           0 :                                 return false;
    3712             :                         }
    3713           0 :                         (r->in.entries)[entries_cntr_0] = *(struct epm_entry_t *)pytalloc_get_ptr(PyList_GET_ITEM(py_entries, entries_cntr_0));
    3714             :                 }
    3715             :         }
    3716           0 :         return true;
    3717             : }
    3718             : 
    3719           0 : static PyObject *unpack_py_epm_Delete_args_out(struct epm_Delete *r)
    3720             : {
    3721           0 :         PyObject *result;
    3722           0 :         result = PyLong_FromUnsignedLongLong((uint32_t)(r->out.result));
    3723           0 :         return result;
    3724             : }
    3725             : 
    3726             : 
    3727           0 : static PyObject *py_epm_Lookup_in_get_inquiry_type(PyObject *obj, void *closure)
    3728             : {
    3729           0 :         struct epm_Lookup *object = pytalloc_get_ptr(obj);
    3730           0 :         PyObject *py_inquiry_type;
    3731           0 :         py_inquiry_type = PyLong_FromUnsignedLongLong((uint32_t)(object->in.inquiry_type));
    3732           0 :         return py_inquiry_type;
    3733             : }
    3734             : 
    3735           0 : static int py_epm_Lookup_in_set_inquiry_type(PyObject *py_obj, PyObject *value, void *closure)
    3736             : {
    3737           0 :         struct epm_Lookup *object = pytalloc_get_ptr(py_obj);
    3738           0 :         if (value == NULL) {
    3739           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.inquiry_type");
    3740           0 :                 return -1;
    3741             :         }
    3742             :         {
    3743           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.inquiry_type));
    3744           0 :                 if (PyLong_Check(value)) {
    3745           0 :                         unsigned long long test_var;
    3746           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    3747           0 :                         if (PyErr_Occurred() != NULL) {
    3748           0 :                                 return -1;
    3749             :                         }
    3750           0 :                         if (test_var > uint_max) {
    3751           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3752             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3753           0 :                                 return -1;
    3754             :                         }
    3755           0 :                         object->in.inquiry_type = test_var;
    3756             :                 } else {
    3757           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3758             :                           PyLong_Type.tp_name);
    3759           0 :                         return -1;
    3760             :                 }
    3761             :         }
    3762           0 :         return 0;
    3763             : }
    3764             : 
    3765           0 : static PyObject *py_epm_Lookup_in_get_object(PyObject *obj, void *closure)
    3766             : {
    3767           0 :         struct epm_Lookup *object = pytalloc_get_ptr(obj);
    3768           0 :         PyObject *py_object;
    3769           0 :         if (object->in.object == NULL) {
    3770           0 :                 Py_RETURN_NONE;
    3771             :         }
    3772           0 :         if (object->in.object == NULL) {
    3773           0 :                 py_object = Py_None;
    3774           0 :                 Py_INCREF(py_object);
    3775             :         } else {
    3776           0 :                 py_object = pytalloc_reference_ex(GUID_Type, object->in.object, object->in.object);
    3777             :         }
    3778           0 :         return py_object;
    3779             : }
    3780             : 
    3781           0 : static int py_epm_Lookup_in_set_object(PyObject *py_obj, PyObject *value, void *closure)
    3782             : {
    3783           0 :         struct epm_Lookup *object = pytalloc_get_ptr(py_obj);
    3784           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.object));
    3785           0 :         if (value == NULL) {
    3786           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.object");
    3787           0 :                 return -1;
    3788             :         }
    3789           0 :         if (value == Py_None) {
    3790           0 :                 object->in.object = NULL;
    3791             :         } else {
    3792           0 :                 object->in.object = NULL;
    3793           0 :                 PY_CHECK_TYPE(GUID_Type, value, return -1;);
    3794           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    3795           0 :                         PyErr_NoMemory();
    3796           0 :                         return -1;
    3797             :                 }
    3798           0 :                 object->in.object = (struct GUID *)pytalloc_get_ptr(value);
    3799             :         }
    3800           0 :         return 0;
    3801             : }
    3802             : 
    3803           0 : static PyObject *py_epm_Lookup_in_get_interface_id(PyObject *obj, void *closure)
    3804             : {
    3805           0 :         struct epm_Lookup *object = pytalloc_get_ptr(obj);
    3806           0 :         PyObject *py_interface_id;
    3807           0 :         if (object->in.interface_id == NULL) {
    3808           0 :                 Py_RETURN_NONE;
    3809             :         }
    3810           0 :         if (object->in.interface_id == NULL) {
    3811           0 :                 py_interface_id = Py_None;
    3812           0 :                 Py_INCREF(py_interface_id);
    3813             :         } else {
    3814           0 :                 py_interface_id = pytalloc_reference_ex(&rpc_if_id_t_Type, object->in.interface_id, object->in.interface_id);
    3815             :         }
    3816           0 :         return py_interface_id;
    3817             : }
    3818             : 
    3819           0 : static int py_epm_Lookup_in_set_interface_id(PyObject *py_obj, PyObject *value, void *closure)
    3820             : {
    3821           0 :         struct epm_Lookup *object = pytalloc_get_ptr(py_obj);
    3822           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.interface_id));
    3823           0 :         if (value == NULL) {
    3824           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.interface_id");
    3825           0 :                 return -1;
    3826             :         }
    3827           0 :         if (value == Py_None) {
    3828           0 :                 object->in.interface_id = NULL;
    3829             :         } else {
    3830           0 :                 object->in.interface_id = NULL;
    3831           0 :                 PY_CHECK_TYPE(&rpc_if_id_t_Type, value, return -1;);
    3832           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    3833           0 :                         PyErr_NoMemory();
    3834           0 :                         return -1;
    3835             :                 }
    3836           0 :                 object->in.interface_id = (struct rpc_if_id_t *)pytalloc_get_ptr(value);
    3837             :         }
    3838           0 :         return 0;
    3839             : }
    3840             : 
    3841           0 : static PyObject *py_epm_Lookup_in_get_vers_option(PyObject *obj, void *closure)
    3842             : {
    3843           0 :         struct epm_Lookup *object = pytalloc_get_ptr(obj);
    3844           0 :         PyObject *py_vers_option;
    3845           0 :         py_vers_option = PyLong_FromUnsignedLongLong((uint32_t)(object->in.vers_option));
    3846           0 :         return py_vers_option;
    3847             : }
    3848             : 
    3849           0 : static int py_epm_Lookup_in_set_vers_option(PyObject *py_obj, PyObject *value, void *closure)
    3850             : {
    3851           0 :         struct epm_Lookup *object = pytalloc_get_ptr(py_obj);
    3852           0 :         if (value == NULL) {
    3853           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.vers_option");
    3854           0 :                 return -1;
    3855             :         }
    3856             :         {
    3857           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.vers_option));
    3858           0 :                 if (PyLong_Check(value)) {
    3859           0 :                         unsigned long long test_var;
    3860           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    3861           0 :                         if (PyErr_Occurred() != NULL) {
    3862           0 :                                 return -1;
    3863             :                         }
    3864           0 :                         if (test_var > uint_max) {
    3865           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3866             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3867           0 :                                 return -1;
    3868             :                         }
    3869           0 :                         object->in.vers_option = test_var;
    3870             :                 } else {
    3871           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3872             :                           PyLong_Type.tp_name);
    3873           0 :                         return -1;
    3874             :                 }
    3875             :         }
    3876           0 :         return 0;
    3877             : }
    3878             : 
    3879           0 : static PyObject *py_epm_Lookup_in_get_entry_handle(PyObject *obj, void *closure)
    3880             : {
    3881           0 :         struct epm_Lookup *object = pytalloc_get_ptr(obj);
    3882           0 :         PyObject *py_entry_handle;
    3883           0 :         if (object->in.entry_handle == NULL) {
    3884           0 :                 Py_RETURN_NONE;
    3885             :         }
    3886           0 :         py_entry_handle = pytalloc_reference_ex(policy_handle_Type, object->in.entry_handle, object->in.entry_handle);
    3887           0 :         return py_entry_handle;
    3888             : }
    3889             : 
    3890           0 : static int py_epm_Lookup_in_set_entry_handle(PyObject *py_obj, PyObject *value, void *closure)
    3891             : {
    3892           0 :         struct epm_Lookup *object = pytalloc_get_ptr(py_obj);
    3893           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.entry_handle));
    3894           0 :         if (value == NULL) {
    3895           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.entry_handle");
    3896           0 :                 return -1;
    3897             :         }
    3898           0 :         object->in.entry_handle = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.entry_handle);
    3899           0 :         if (object->in.entry_handle == NULL) {
    3900           0 :                 PyErr_NoMemory();
    3901           0 :                 return -1;
    3902             :         }
    3903           0 :         PY_CHECK_TYPE(policy_handle_Type, value, return -1;);
    3904           0 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    3905           0 :                 PyErr_NoMemory();
    3906           0 :                 return -1;
    3907             :         }
    3908           0 :         object->in.entry_handle = (struct policy_handle *)pytalloc_get_ptr(value);
    3909           0 :         return 0;
    3910             : }
    3911             : 
    3912           0 : static PyObject *py_epm_Lookup_out_get_entry_handle(PyObject *obj, void *closure)
    3913             : {
    3914           0 :         struct epm_Lookup *object = pytalloc_get_ptr(obj);
    3915           0 :         PyObject *py_entry_handle;
    3916           0 :         if (object->out.entry_handle == NULL) {
    3917           0 :                 Py_RETURN_NONE;
    3918             :         }
    3919           0 :         py_entry_handle = pytalloc_reference_ex(policy_handle_Type, object->out.entry_handle, object->out.entry_handle);
    3920           0 :         return py_entry_handle;
    3921             : }
    3922             : 
    3923           0 : static int py_epm_Lookup_out_set_entry_handle(PyObject *py_obj, PyObject *value, void *closure)
    3924             : {
    3925           0 :         struct epm_Lookup *object = pytalloc_get_ptr(py_obj);
    3926           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.entry_handle));
    3927           0 :         if (value == NULL) {
    3928           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.entry_handle");
    3929           0 :                 return -1;
    3930             :         }
    3931           0 :         object->out.entry_handle = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.entry_handle);
    3932           0 :         if (object->out.entry_handle == NULL) {
    3933           0 :                 PyErr_NoMemory();
    3934           0 :                 return -1;
    3935             :         }
    3936           0 :         PY_CHECK_TYPE(policy_handle_Type, value, return -1;);
    3937           0 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    3938           0 :                 PyErr_NoMemory();
    3939           0 :                 return -1;
    3940             :         }
    3941           0 :         object->out.entry_handle = (struct policy_handle *)pytalloc_get_ptr(value);
    3942           0 :         return 0;
    3943             : }
    3944             : 
    3945           0 : static PyObject *py_epm_Lookup_in_get_max_ents(PyObject *obj, void *closure)
    3946             : {
    3947           0 :         struct epm_Lookup *object = pytalloc_get_ptr(obj);
    3948           0 :         PyObject *py_max_ents;
    3949           0 :         py_max_ents = PyLong_FromUnsignedLongLong((uint32_t)(object->in.max_ents));
    3950           0 :         return py_max_ents;
    3951             : }
    3952             : 
    3953           0 : static int py_epm_Lookup_in_set_max_ents(PyObject *py_obj, PyObject *value, void *closure)
    3954             : {
    3955           0 :         struct epm_Lookup *object = pytalloc_get_ptr(py_obj);
    3956           0 :         if (value == NULL) {
    3957           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.max_ents");
    3958           0 :                 return -1;
    3959             :         }
    3960             :         {
    3961           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.max_ents));
    3962           0 :                 if (PyLong_Check(value)) {
    3963           0 :                         unsigned long long test_var;
    3964           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    3965           0 :                         if (PyErr_Occurred() != NULL) {
    3966           0 :                                 return -1;
    3967             :                         }
    3968           0 :                         if (test_var > uint_max) {
    3969           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3970             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3971           0 :                                 return -1;
    3972             :                         }
    3973           0 :                         object->in.max_ents = test_var;
    3974             :                 } else {
    3975           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3976             :                           PyLong_Type.tp_name);
    3977           0 :                         return -1;
    3978             :                 }
    3979             :         }
    3980           0 :         return 0;
    3981             : }
    3982             : 
    3983           0 : static PyObject *py_epm_Lookup_out_get_num_ents(PyObject *obj, void *closure)
    3984             : {
    3985           0 :         struct epm_Lookup *object = pytalloc_get_ptr(obj);
    3986           0 :         PyObject *py_num_ents;
    3987           0 :         if (object->out.num_ents == NULL) {
    3988           0 :                 Py_RETURN_NONE;
    3989             :         }
    3990           0 :         py_num_ents = PyLong_FromUnsignedLongLong((uint32_t)(*object->out.num_ents));
    3991           0 :         return py_num_ents;
    3992             : }
    3993             : 
    3994           0 : static int py_epm_Lookup_out_set_num_ents(PyObject *py_obj, PyObject *value, void *closure)
    3995             : {
    3996           0 :         struct epm_Lookup *object = pytalloc_get_ptr(py_obj);
    3997           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.num_ents));
    3998           0 :         if (value == NULL) {
    3999           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.num_ents");
    4000           0 :                 return -1;
    4001             :         }
    4002           0 :         object->out.num_ents = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.num_ents);
    4003           0 :         if (object->out.num_ents == NULL) {
    4004           0 :                 PyErr_NoMemory();
    4005           0 :                 return -1;
    4006             :         }
    4007             :         {
    4008           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->out.num_ents));
    4009           0 :                 if (PyLong_Check(value)) {
    4010           0 :                         unsigned long long test_var;
    4011           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    4012           0 :                         if (PyErr_Occurred() != NULL) {
    4013           0 :                                 return -1;
    4014             :                         }
    4015           0 :                         if (test_var > uint_max) {
    4016           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4017             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4018           0 :                                 return -1;
    4019             :                         }
    4020           0 :                         *object->out.num_ents = test_var;
    4021             :                 } else {
    4022           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4023             :                           PyLong_Type.tp_name);
    4024           0 :                         return -1;
    4025             :                 }
    4026             :         }
    4027           0 :         return 0;
    4028             : }
    4029             : 
    4030           0 : static PyObject *py_epm_Lookup_out_get_entries(PyObject *obj, void *closure)
    4031             : {
    4032           0 :         struct epm_Lookup *object = pytalloc_get_ptr(obj);
    4033           0 :         PyObject *py_entries;
    4034           0 :         py_entries = PyList_New(*object->out.num_ents);
    4035           0 :         if (py_entries == NULL) {
    4036           0 :                 return NULL;
    4037             :         }
    4038             :         {
    4039             :                 int entries_cntr_0;
    4040           0 :                 for (entries_cntr_0 = 0; entries_cntr_0 < (*object->out.num_ents); entries_cntr_0++) {
    4041           0 :                         PyObject *py_entries_0;
    4042           0 :                         py_entries_0 = pytalloc_reference_ex(&epm_entry_t_Type, object->out.entries, &(object->out.entries)[entries_cntr_0]);
    4043           0 :                         PyList_SetItem(py_entries, entries_cntr_0, py_entries_0);
    4044             :                 }
    4045             :         }
    4046           0 :         return py_entries;
    4047             : }
    4048             : 
    4049           0 : static int py_epm_Lookup_out_set_entries(PyObject *py_obj, PyObject *value, void *closure)
    4050             : {
    4051           0 :         struct epm_Lookup *object = pytalloc_get_ptr(py_obj);
    4052           0 :         if (value == NULL) {
    4053           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.entries");
    4054           0 :                 return -1;
    4055             :         }
    4056           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
    4057             :         {
    4058           0 :                 int entries_cntr_0;
    4059           0 :                 object->out.entries = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.entries, PyList_GET_SIZE(value));
    4060           0 :                 if (!object->out.entries) { return -1; }
    4061           0 :                 talloc_set_name_const(object->out.entries, "ARRAY: object->out.entries");
    4062           0 :                 for (entries_cntr_0 = 0; entries_cntr_0 < PyList_GET_SIZE(value); entries_cntr_0++) {
    4063           0 :                         if (PyList_GET_ITEM(value, entries_cntr_0) == NULL) {
    4064           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->out.entries)[entries_cntr_0]");
    4065           0 :                                 return -1;
    4066             :                         }
    4067           0 :                         PY_CHECK_TYPE(&epm_entry_t_Type, PyList_GET_ITEM(value, entries_cntr_0), return -1;);
    4068           0 :                         if (talloc_reference(object->out.entries, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, entries_cntr_0))) == NULL) {
    4069           0 :                                 PyErr_NoMemory();
    4070           0 :                                 return -1;
    4071             :                         }
    4072           0 :                         (object->out.entries)[entries_cntr_0] = *(struct epm_entry_t *)pytalloc_get_ptr(PyList_GET_ITEM(value, entries_cntr_0));
    4073             :                 }
    4074             :         }
    4075           0 :         return 0;
    4076             : }
    4077             : 
    4078           0 : static PyObject *py_epm_Lookup_get_result(PyObject *obj, void *closure)
    4079             : {
    4080           0 :         struct epm_Lookup *object = pytalloc_get_ptr(obj);
    4081           0 :         PyObject *py_result;
    4082           0 :         py_result = PyLong_FromUnsignedLongLong((uint32_t)(object->out.result));
    4083           0 :         return py_result;
    4084             : }
    4085             : 
    4086           0 : static int py_epm_Lookup_set_result(PyObject *py_obj, PyObject *value, void *closure)
    4087             : {
    4088           0 :         struct epm_Lookup *object = pytalloc_get_ptr(py_obj);
    4089           0 :         if (value == NULL) {
    4090           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.result");
    4091           0 :                 return -1;
    4092             :         }
    4093             :         {
    4094           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->out.result));
    4095           0 :                 if (PyLong_Check(value)) {
    4096           0 :                         unsigned long long test_var;
    4097           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    4098           0 :                         if (PyErr_Occurred() != NULL) {
    4099           0 :                                 return -1;
    4100             :                         }
    4101           0 :                         if (test_var > uint_max) {
    4102           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4103             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4104           0 :                                 return -1;
    4105             :                         }
    4106           0 :                         object->out.result = test_var;
    4107             :                 } else {
    4108           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4109             :                           PyLong_Type.tp_name);
    4110           0 :                         return -1;
    4111             :                 }
    4112             :         }
    4113           0 :         return 0;
    4114             : }
    4115             : 
    4116             : static PyGetSetDef py_epm_Lookup_getsetters[] = {
    4117             :         {
    4118             :                 .name = discard_const_p(char, "in_inquiry_type"),
    4119             :                 .get = py_epm_Lookup_in_get_inquiry_type,
    4120             :                 .set = py_epm_Lookup_in_set_inquiry_type,
    4121             :                 .doc = discard_const_p(char, "PIDL-generated element of base type epm_InquiryType")
    4122             :         },
    4123             :         {
    4124             :                 .name = discard_const_p(char, "in_object"),
    4125             :                 .get = py_epm_Lookup_in_get_object,
    4126             :                 .set = py_epm_Lookup_in_set_object,
    4127             :                 .doc = discard_const_p(char, "PIDL-generated element of base type GUID")
    4128             :         },
    4129             :         {
    4130             :                 .name = discard_const_p(char, "in_interface_id"),
    4131             :                 .get = py_epm_Lookup_in_get_interface_id,
    4132             :                 .set = py_epm_Lookup_in_set_interface_id,
    4133             :                 .doc = discard_const_p(char, "PIDL-generated element of base type rpc_if_id_t")
    4134             :         },
    4135             :         {
    4136             :                 .name = discard_const_p(char, "in_vers_option"),
    4137             :                 .get = py_epm_Lookup_in_get_vers_option,
    4138             :                 .set = py_epm_Lookup_in_set_vers_option,
    4139             :                 .doc = discard_const_p(char, "PIDL-generated element of base type epm_VersionOption")
    4140             :         },
    4141             :         {
    4142             :                 .name = discard_const_p(char, "in_entry_handle"),
    4143             :                 .get = py_epm_Lookup_in_get_entry_handle,
    4144             :                 .set = py_epm_Lookup_in_set_entry_handle,
    4145             :                 .doc = discard_const_p(char, "PIDL-generated element of base type policy_handle")
    4146             :         },
    4147             :         {
    4148             :                 .name = discard_const_p(char, "out_entry_handle"),
    4149             :                 .get = py_epm_Lookup_out_get_entry_handle,
    4150             :                 .set = py_epm_Lookup_out_set_entry_handle,
    4151             :                 .doc = discard_const_p(char, "PIDL-generated element of base type policy_handle")
    4152             :         },
    4153             :         {
    4154             :                 .name = discard_const_p(char, "in_max_ents"),
    4155             :                 .get = py_epm_Lookup_in_get_max_ents,
    4156             :                 .set = py_epm_Lookup_in_set_max_ents,
    4157             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    4158             :         },
    4159             :         {
    4160             :                 .name = discard_const_p(char, "out_num_ents"),
    4161             :                 .get = py_epm_Lookup_out_get_num_ents,
    4162             :                 .set = py_epm_Lookup_out_set_num_ents,
    4163             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    4164             :         },
    4165             :         {
    4166             :                 .name = discard_const_p(char, "out_entries"),
    4167             :                 .get = py_epm_Lookup_out_get_entries,
    4168             :                 .set = py_epm_Lookup_out_set_entries,
    4169             :                 .doc = discard_const_p(char, "PIDL-generated element of base type epm_entry_t")
    4170             :         },
    4171             :         {
    4172             :                 .name = discard_const_p(char, "result"),
    4173             :                 .get = py_epm_Lookup_get_result,
    4174             :                 .set = py_epm_Lookup_set_result,
    4175             :                 .doc = discard_const_p(char, "PIDL-generated element of type uint32")
    4176             :         },
    4177             :         { .name = NULL }
    4178             : };
    4179             : 
    4180           0 : static PyObject *py_epm_Lookup_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    4181             : {
    4182           0 :         PyObject *self = pytalloc_new(struct epm_Lookup, type);
    4183           0 :         struct epm_Lookup *_self = (struct epm_Lookup *)pytalloc_get_ptr(self);
    4184           0 :         TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
    4185           0 :         _self->in.entry_handle = talloc_zero(mem_ctx, struct policy_handle);
    4186           0 :         _self->out.entry_handle = talloc_zero(mem_ctx, struct policy_handle);
    4187           0 :         _self->out.num_ents = talloc_zero(mem_ctx, uint32_t);
    4188           0 :         return self;
    4189             : }
    4190             : 
    4191           0 : static PyObject *py_epm_Lookup_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
    4192             : {
    4193             : 
    4194             : 
    4195           0 :         return PyLong_FromLong(2);
    4196             : }
    4197             : 
    4198           0 : static PyObject *py_epm_Lookup_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
    4199             : {
    4200           0 :         const struct ndr_interface_call *call = NULL;
    4201           0 :         struct epm_Lookup *object = pytalloc_get_ptr(py_obj);
    4202           0 :         PyObject *ret = NULL;
    4203           0 :         struct ndr_push *push = NULL;
    4204           0 :         DATA_BLOB blob;
    4205           0 :         enum ndr_err_code err;
    4206             : 
    4207           0 :         if (ndr_table_epmapper.num_calls < 3) {
    4208           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_epm_Lookup_ndr_pack");
    4209           0 :                 return NULL;
    4210             :         }
    4211           0 :         call = &ndr_table_epmapper.calls[2];
    4212             : 
    4213           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
    4214           0 :         if (push == NULL) {
    4215           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    4216           0 :                 return NULL;
    4217             :         }
    4218             : 
    4219           0 :         push->flags |= ndr_push_flags;
    4220             : 
    4221           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
    4222           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    4223           0 :                 TALLOC_FREE(push);
    4224           0 :                 PyErr_SetNdrError(err);
    4225           0 :                 return NULL;
    4226             :         }
    4227           0 :         blob = ndr_push_blob(push);
    4228           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
    4229           0 :         TALLOC_FREE(push);
    4230           0 :         return ret;
    4231             : }
    4232             : 
    4233           0 : static PyObject *py_epm_Lookup_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    4234             : {
    4235           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    4236           0 :         PyObject *bigendian_obj = NULL;
    4237           0 :         PyObject *ndr64_obj = NULL;
    4238           0 :         libndr_flags ndr_push_flags = 0;
    4239             : 
    4240           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
    4241             :                 discard_const_p(char *, kwnames),
    4242             :                 &bigendian_obj,
    4243             :                 &ndr64_obj)) {
    4244           0 :                 return NULL;
    4245             :         }
    4246             : 
    4247           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    4248           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    4249             :         }
    4250           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    4251           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    4252             :         }
    4253             : 
    4254           0 :         return py_epm_Lookup_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
    4255             : }
    4256             : 
    4257           0 : static PyObject *py_epm_Lookup_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    4258             : {
    4259           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    4260           0 :         PyObject *bigendian_obj = NULL;
    4261           0 :         PyObject *ndr64_obj = NULL;
    4262           0 :         libndr_flags ndr_push_flags = 0;
    4263             : 
    4264           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
    4265             :                 discard_const_p(char *, kwnames),
    4266             :                 &bigendian_obj,
    4267             :                 &ndr64_obj)) {
    4268           0 :                 return NULL;
    4269             :         }
    4270             : 
    4271           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    4272           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    4273             :         }
    4274           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    4275           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    4276             :         }
    4277             : 
    4278           0 :         return py_epm_Lookup_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
    4279             : }
    4280             : 
    4281           0 : static PyObject *py_epm_Lookup_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
    4282             : {
    4283           0 :         const struct ndr_interface_call *call = NULL;
    4284           0 :         struct epm_Lookup *object = pytalloc_get_ptr(py_obj);
    4285           0 :         struct ndr_pull *pull = NULL;
    4286           0 :         enum ndr_err_code err;
    4287             : 
    4288           0 :         if (ndr_table_epmapper.num_calls < 3) {
    4289           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_epm_Lookup_ndr_unpack");
    4290           0 :                 return NULL;
    4291             :         }
    4292           0 :         call = &ndr_table_epmapper.calls[2];
    4293             : 
    4294           0 :         pull = ndr_pull_init_blob(blob, object);
    4295           0 :         if (pull == NULL) {
    4296           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    4297           0 :                 return NULL;
    4298             :         }
    4299             : 
    4300           0 :         pull->flags |= ndr_pull_flags;
    4301             : 
    4302           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
    4303           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    4304           0 :                 TALLOC_FREE(pull);
    4305           0 :                 PyErr_SetNdrError(err);
    4306           0 :                 return NULL;
    4307             :         }
    4308           0 :         if (!allow_remaining) {
    4309           0 :                 uint32_t highest_ofs;
    4310             : 
    4311           0 :                 if (pull->offset > pull->relative_highest_offset) {
    4312           0 :                         highest_ofs = pull->offset;
    4313             :                 } else {
    4314           0 :                         highest_ofs = pull->relative_highest_offset;
    4315             :                 }
    4316           0 :                 if (highest_ofs < pull->data_size) {
    4317           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
    4318             :                                 "not all bytes consumed ofs[%u] size[%u]",
    4319             :                                 highest_ofs, pull->data_size);
    4320           0 :                         TALLOC_FREE(pull);
    4321           0 :                         PyErr_SetNdrError(err);
    4322           0 :                         return NULL;
    4323             :                 }
    4324             :         }
    4325             : 
    4326           0 :         TALLOC_FREE(pull);
    4327           0 :         Py_RETURN_NONE;
    4328             : }
    4329             : 
    4330           0 : static PyObject *py_epm_Lookup_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    4331             : {
    4332           0 :         DATA_BLOB blob;
    4333           0 :         Py_ssize_t blob_length = 0;
    4334           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    4335           0 :         PyObject *bigendian_obj = NULL;
    4336           0 :         PyObject *ndr64_obj = NULL;
    4337           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    4338           0 :         PyObject *allow_remaining_obj = NULL;
    4339           0 :         bool allow_remaining = false;
    4340             : 
    4341           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
    4342             :                 discard_const_p(char *, kwnames),
    4343             :                 &blob.data, &blob_length,
    4344             :                 &bigendian_obj,
    4345             :                 &ndr64_obj,
    4346             :                 &allow_remaining_obj)) {
    4347           0 :                 return NULL;
    4348             :         }
    4349           0 :         blob.length = blob_length;
    4350             : 
    4351           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    4352           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    4353             :         }
    4354           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    4355           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    4356             :         }
    4357             : 
    4358           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    4359           0 :                 allow_remaining = true;
    4360             :         }
    4361             : 
    4362           0 :         return py_epm_Lookup_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
    4363             : }
    4364             : 
    4365           0 : static PyObject *py_epm_Lookup_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    4366             : {
    4367           0 :         DATA_BLOB blob;
    4368           0 :         Py_ssize_t blob_length = 0;
    4369           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    4370           0 :         PyObject *bigendian_obj = NULL;
    4371           0 :         PyObject *ndr64_obj = NULL;
    4372           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    4373           0 :         PyObject *allow_remaining_obj = NULL;
    4374           0 :         bool allow_remaining = false;
    4375             : 
    4376           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
    4377             :                 discard_const_p(char *, kwnames),
    4378             :                 &blob.data, &blob_length,
    4379             :                 &bigendian_obj,
    4380             :                 &ndr64_obj,
    4381             :                 &allow_remaining_obj)) {
    4382           0 :                 return NULL;
    4383             :         }
    4384           0 :         blob.length = blob_length;
    4385             : 
    4386           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    4387           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    4388             :         }
    4389           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    4390           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    4391             :         }
    4392             : 
    4393           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    4394           0 :                 allow_remaining = true;
    4395             :         }
    4396             : 
    4397           0 :         return py_epm_Lookup_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
    4398             : }
    4399             : 
    4400           0 : static PyObject *py_epm_Lookup_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
    4401             : {
    4402           0 :         const struct ndr_interface_call *call = NULL;
    4403           0 :         struct epm_Lookup *object = pytalloc_get_ptr(py_obj);
    4404           0 :         PyObject *ret;
    4405           0 :         char *retstr;
    4406             : 
    4407           0 :         if (ndr_table_epmapper.num_calls < 3) {
    4408           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_epm_Lookup_ndr_print");
    4409           0 :                 return NULL;
    4410             :         }
    4411           0 :         call = &ndr_table_epmapper.calls[2];
    4412             : 
    4413           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
    4414           0 :         ret = PyUnicode_FromString(retstr);
    4415           0 :         TALLOC_FREE(retstr);
    4416             : 
    4417           0 :         return ret;
    4418             : }
    4419             : 
    4420           0 : static PyObject *py_epm_Lookup_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    4421             : {
    4422           0 :         return py_epm_Lookup_ndr_print(py_obj, "epm_Lookup_in", NDR_IN);
    4423             : }
    4424             : 
    4425           0 : static PyObject *py_epm_Lookup_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    4426             : {
    4427           0 :         return py_epm_Lookup_ndr_print(py_obj, "epm_Lookup_out", NDR_OUT);
    4428             : }
    4429             : 
    4430             : static PyMethodDef py_epm_Lookup_methods[] = {
    4431             :         { "opnum", (PyCFunction)py_epm_Lookup_ndr_opnum, METH_NOARGS|METH_CLASS,
    4432             :                 "epmapper.epm_Lookup.opnum() -> 2 (0x02) " },
    4433             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_Lookup_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
    4434             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
    4435             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_Lookup_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
    4436             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
    4437             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_Lookup_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
    4438             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
    4439             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_Lookup_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
    4440             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
    4441             :         { "__ndr_print_in__", (PyCFunction)py_epm_Lookup_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
    4442             :         { "__ndr_print_out__", (PyCFunction)py_epm_Lookup_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
    4443             :         { NULL, NULL, 0, NULL }
    4444             : };
    4445             : 
    4446             : 
    4447             : static PyTypeObject epm_Lookup_Type = {
    4448             :         PyVarObject_HEAD_INIT(NULL, 0)
    4449             :         .tp_name = "epmapper.epm_Lookup",
    4450             :         .tp_getset = py_epm_Lookup_getsetters,
    4451             :         .tp_methods = py_epm_Lookup_methods,
    4452             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    4453             :         .tp_new = py_epm_Lookup_new,
    4454             : };
    4455             : 
    4456           0 : static bool pack_py_epm_Lookup_args_in(PyObject *args, PyObject *kwargs, struct epm_Lookup *r)
    4457             : {
    4458           0 :         PyObject *py_inquiry_type;
    4459           0 :         PyObject *py_object;
    4460           0 :         PyObject *py_interface_id;
    4461           0 :         PyObject *py_vers_option;
    4462           0 :         PyObject *py_entry_handle;
    4463           0 :         PyObject *py_max_ents;
    4464           0 :         const char *kwnames[] = {
    4465             :                 "inquiry_type", "object", "interface_id", "vers_option", "entry_handle", "max_ents", NULL
    4466             :         };
    4467             : 
    4468           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:epm_Lookup", discard_const_p(char *, kwnames), &py_inquiry_type, &py_object, &py_interface_id, &py_vers_option, &py_entry_handle, &py_max_ents)) {
    4469           0 :                 return false;
    4470             :         }
    4471             : 
    4472           0 :         if (py_inquiry_type == NULL) {
    4473           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.inquiry_type");
    4474           0 :                 return false;
    4475             :         }
    4476             :         {
    4477           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.inquiry_type));
    4478           0 :                 if (PyLong_Check(py_inquiry_type)) {
    4479           0 :                         unsigned long long test_var;
    4480           0 :                         test_var = PyLong_AsUnsignedLongLong(py_inquiry_type);
    4481           0 :                         if (PyErr_Occurred() != NULL) {
    4482           0 :                                 return false;
    4483             :                         }
    4484           0 :                         if (test_var > uint_max) {
    4485           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4486             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4487           0 :                                 return false;
    4488             :                         }
    4489           0 :                         r->in.inquiry_type = test_var;
    4490             :                 } else {
    4491           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4492             :                           PyLong_Type.tp_name);
    4493           0 :                         return false;
    4494             :                 }
    4495             :         }
    4496           0 :         if (py_object == NULL) {
    4497           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.object");
    4498           0 :                 return false;
    4499             :         }
    4500           0 :         if (py_object == Py_None) {
    4501           0 :                 r->in.object = NULL;
    4502             :         } else {
    4503           0 :                 r->in.object = NULL;
    4504           0 :                 PY_CHECK_TYPE(GUID_Type, py_object, return false;);
    4505           0 :                 if (talloc_reference(r, pytalloc_get_mem_ctx(py_object)) == NULL) {
    4506           0 :                         PyErr_NoMemory();
    4507           0 :                         return false;
    4508             :                 }
    4509           0 :                 r->in.object = (struct GUID *)pytalloc_get_ptr(py_object);
    4510             :         }
    4511           0 :         if (py_interface_id == NULL) {
    4512           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.interface_id");
    4513           0 :                 return false;
    4514             :         }
    4515           0 :         if (py_interface_id == Py_None) {
    4516           0 :                 r->in.interface_id = NULL;
    4517             :         } else {
    4518           0 :                 r->in.interface_id = NULL;
    4519           0 :                 PY_CHECK_TYPE(&rpc_if_id_t_Type, py_interface_id, return false;);
    4520           0 :                 if (talloc_reference(r, pytalloc_get_mem_ctx(py_interface_id)) == NULL) {
    4521           0 :                         PyErr_NoMemory();
    4522           0 :                         return false;
    4523             :                 }
    4524           0 :                 r->in.interface_id = (struct rpc_if_id_t *)pytalloc_get_ptr(py_interface_id);
    4525             :         }
    4526           0 :         if (py_vers_option == NULL) {
    4527           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.vers_option");
    4528           0 :                 return false;
    4529             :         }
    4530             :         {
    4531           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.vers_option));
    4532           0 :                 if (PyLong_Check(py_vers_option)) {
    4533           0 :                         unsigned long long test_var;
    4534           0 :                         test_var = PyLong_AsUnsignedLongLong(py_vers_option);
    4535           0 :                         if (PyErr_Occurred() != NULL) {
    4536           0 :                                 return false;
    4537             :                         }
    4538           0 :                         if (test_var > uint_max) {
    4539           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4540             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4541           0 :                                 return false;
    4542             :                         }
    4543           0 :                         r->in.vers_option = test_var;
    4544             :                 } else {
    4545           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4546             :                           PyLong_Type.tp_name);
    4547           0 :                         return false;
    4548             :                 }
    4549             :         }
    4550           0 :         if (py_entry_handle == NULL) {
    4551           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.entry_handle");
    4552           0 :                 return false;
    4553             :         }
    4554           0 :         r->in.entry_handle = talloc_ptrtype(r, r->in.entry_handle);
    4555           0 :         if (r->in.entry_handle == NULL) {
    4556           0 :                 PyErr_NoMemory();
    4557           0 :                 return false;
    4558             :         }
    4559           0 :         PY_CHECK_TYPE(policy_handle_Type, py_entry_handle, return false;);
    4560           0 :         if (talloc_reference(r, pytalloc_get_mem_ctx(py_entry_handle)) == NULL) {
    4561           0 :                 PyErr_NoMemory();
    4562           0 :                 return false;
    4563             :         }
    4564           0 :         r->in.entry_handle = (struct policy_handle *)pytalloc_get_ptr(py_entry_handle);
    4565           0 :         if (py_max_ents == NULL) {
    4566           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.max_ents");
    4567           0 :                 return false;
    4568             :         }
    4569             :         {
    4570           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.max_ents));
    4571           0 :                 if (PyLong_Check(py_max_ents)) {
    4572           0 :                         unsigned long long test_var;
    4573           0 :                         test_var = PyLong_AsUnsignedLongLong(py_max_ents);
    4574           0 :                         if (PyErr_Occurred() != NULL) {
    4575           0 :                                 return false;
    4576             :                         }
    4577           0 :                         if (test_var > uint_max) {
    4578           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4579             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4580           0 :                                 return false;
    4581             :                         }
    4582           0 :                         r->in.max_ents = test_var;
    4583             :                 } else {
    4584           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4585             :                           PyLong_Type.tp_name);
    4586           0 :                         return false;
    4587             :                 }
    4588             :         }
    4589           0 :         return true;
    4590             : }
    4591             : 
    4592           0 : static PyObject *unpack_py_epm_Lookup_args_out(struct epm_Lookup *r)
    4593             : {
    4594           0 :         PyObject *result;
    4595           0 :         PyObject *py_entry_handle;
    4596           0 :         PyObject *py_entries;
    4597           0 :         result = PyTuple_New(3);
    4598           0 :         py_entry_handle = pytalloc_reference_ex(policy_handle_Type, r->out.entry_handle, r->out.entry_handle);
    4599           0 :         PyTuple_SetItem(result, 0, py_entry_handle);
    4600           0 :         py_entries = PyList_New(*r->out.num_ents);
    4601           0 :         if (py_entries == NULL) {
    4602           0 :                 return NULL;
    4603             :         }
    4604             :         {
    4605             :                 int entries_cntr_0;
    4606           0 :                 for (entries_cntr_0 = 0; entries_cntr_0 < (*r->out.num_ents); entries_cntr_0++) {
    4607           0 :                         PyObject *py_entries_0;
    4608           0 :                         py_entries_0 = pytalloc_reference_ex(&epm_entry_t_Type, r->out.entries, &(r->out.entries)[entries_cntr_0]);
    4609           0 :                         PyList_SetItem(py_entries, entries_cntr_0, py_entries_0);
    4610             :                 }
    4611             :         }
    4612           0 :         PyTuple_SetItem(result, 1, py_entries);
    4613           0 :         PyTuple_SetItem(result, 2, PyLong_FromUnsignedLongLong((uint32_t)(r->out.result)));
    4614           0 :         return result;
    4615             : }
    4616             : 
    4617             : 
    4618           0 : static PyObject *py_epm_Map_in_get_object(PyObject *obj, void *closure)
    4619             : {
    4620           0 :         struct epm_Map *object = pytalloc_get_ptr(obj);
    4621           0 :         PyObject *py_object;
    4622           0 :         if (object->in.object == NULL) {
    4623           0 :                 Py_RETURN_NONE;
    4624             :         }
    4625           0 :         if (object->in.object == NULL) {
    4626           0 :                 py_object = Py_None;
    4627           0 :                 Py_INCREF(py_object);
    4628             :         } else {
    4629           0 :                 py_object = pytalloc_reference_ex(GUID_Type, object->in.object, object->in.object);
    4630             :         }
    4631           0 :         return py_object;
    4632             : }
    4633             : 
    4634          48 : static int py_epm_Map_in_set_object(PyObject *py_obj, PyObject *value, void *closure)
    4635             : {
    4636          48 :         struct epm_Map *object = pytalloc_get_ptr(py_obj);
    4637          48 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.object));
    4638          48 :         if (value == NULL) {
    4639           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.object");
    4640           0 :                 return -1;
    4641             :         }
    4642          48 :         if (value == Py_None) {
    4643           0 :                 object->in.object = NULL;
    4644             :         } else {
    4645          48 :                 object->in.object = NULL;
    4646          48 :                 PY_CHECK_TYPE(GUID_Type, value, return -1;);
    4647          48 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    4648           0 :                         PyErr_NoMemory();
    4649           0 :                         return -1;
    4650             :                 }
    4651          48 :                 object->in.object = (struct GUID *)pytalloc_get_ptr(value);
    4652             :         }
    4653          48 :         return 0;
    4654             : }
    4655             : 
    4656           0 : static PyObject *py_epm_Map_in_get_map_tower(PyObject *obj, void *closure)
    4657             : {
    4658           0 :         struct epm_Map *object = pytalloc_get_ptr(obj);
    4659           0 :         PyObject *py_map_tower;
    4660           0 :         if (object->in.map_tower == NULL) {
    4661           0 :                 Py_RETURN_NONE;
    4662             :         }
    4663           0 :         if (object->in.map_tower == NULL) {
    4664           0 :                 py_map_tower = Py_None;
    4665           0 :                 Py_INCREF(py_map_tower);
    4666             :         } else {
    4667           0 :                 py_map_tower = pytalloc_reference_ex(&epm_twr_t_Type, object->in.map_tower, object->in.map_tower);
    4668             :         }
    4669           0 :         return py_map_tower;
    4670             : }
    4671             : 
    4672          48 : static int py_epm_Map_in_set_map_tower(PyObject *py_obj, PyObject *value, void *closure)
    4673             : {
    4674          48 :         struct epm_Map *object = pytalloc_get_ptr(py_obj);
    4675          48 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.map_tower));
    4676          48 :         if (value == NULL) {
    4677           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.map_tower");
    4678           0 :                 return -1;
    4679             :         }
    4680          48 :         if (value == Py_None) {
    4681           0 :                 object->in.map_tower = NULL;
    4682             :         } else {
    4683          48 :                 object->in.map_tower = NULL;
    4684          48 :                 PY_CHECK_TYPE(&epm_twr_t_Type, value, return -1;);
    4685          48 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    4686           0 :                         PyErr_NoMemory();
    4687           0 :                         return -1;
    4688             :                 }
    4689          48 :                 object->in.map_tower = (struct epm_twr_t *)pytalloc_get_ptr(value);
    4690             :         }
    4691          48 :         return 0;
    4692             : }
    4693             : 
    4694           0 : static PyObject *py_epm_Map_in_get_entry_handle(PyObject *obj, void *closure)
    4695             : {
    4696           0 :         struct epm_Map *object = pytalloc_get_ptr(obj);
    4697           0 :         PyObject *py_entry_handle;
    4698           0 :         if (object->in.entry_handle == NULL) {
    4699           0 :                 Py_RETURN_NONE;
    4700             :         }
    4701           0 :         py_entry_handle = pytalloc_reference_ex(policy_handle_Type, object->in.entry_handle, object->in.entry_handle);
    4702           0 :         return py_entry_handle;
    4703             : }
    4704             : 
    4705          48 : static int py_epm_Map_in_set_entry_handle(PyObject *py_obj, PyObject *value, void *closure)
    4706             : {
    4707          48 :         struct epm_Map *object = pytalloc_get_ptr(py_obj);
    4708          48 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.entry_handle));
    4709          48 :         if (value == NULL) {
    4710           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.entry_handle");
    4711           0 :                 return -1;
    4712             :         }
    4713          48 :         object->in.entry_handle = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.entry_handle);
    4714          48 :         if (object->in.entry_handle == NULL) {
    4715           0 :                 PyErr_NoMemory();
    4716           0 :                 return -1;
    4717             :         }
    4718          48 :         PY_CHECK_TYPE(policy_handle_Type, value, return -1;);
    4719          48 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    4720           0 :                 PyErr_NoMemory();
    4721           0 :                 return -1;
    4722             :         }
    4723          48 :         object->in.entry_handle = (struct policy_handle *)pytalloc_get_ptr(value);
    4724          48 :         return 0;
    4725             : }
    4726             : 
    4727           0 : static PyObject *py_epm_Map_out_get_entry_handle(PyObject *obj, void *closure)
    4728             : {
    4729           0 :         struct epm_Map *object = pytalloc_get_ptr(obj);
    4730           0 :         PyObject *py_entry_handle;
    4731           0 :         if (object->out.entry_handle == NULL) {
    4732           0 :                 Py_RETURN_NONE;
    4733             :         }
    4734           0 :         py_entry_handle = pytalloc_reference_ex(policy_handle_Type, object->out.entry_handle, object->out.entry_handle);
    4735           0 :         return py_entry_handle;
    4736             : }
    4737             : 
    4738           0 : static int py_epm_Map_out_set_entry_handle(PyObject *py_obj, PyObject *value, void *closure)
    4739             : {
    4740           0 :         struct epm_Map *object = pytalloc_get_ptr(py_obj);
    4741           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.entry_handle));
    4742           0 :         if (value == NULL) {
    4743           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.entry_handle");
    4744           0 :                 return -1;
    4745             :         }
    4746           0 :         object->out.entry_handle = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.entry_handle);
    4747           0 :         if (object->out.entry_handle == NULL) {
    4748           0 :                 PyErr_NoMemory();
    4749           0 :                 return -1;
    4750             :         }
    4751           0 :         PY_CHECK_TYPE(policy_handle_Type, value, return -1;);
    4752           0 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    4753           0 :                 PyErr_NoMemory();
    4754           0 :                 return -1;
    4755             :         }
    4756           0 :         object->out.entry_handle = (struct policy_handle *)pytalloc_get_ptr(value);
    4757           0 :         return 0;
    4758             : }
    4759             : 
    4760           0 : static PyObject *py_epm_Map_in_get_max_towers(PyObject *obj, void *closure)
    4761             : {
    4762           0 :         struct epm_Map *object = pytalloc_get_ptr(obj);
    4763           0 :         PyObject *py_max_towers;
    4764           0 :         py_max_towers = PyLong_FromUnsignedLongLong((uint32_t)(object->in.max_towers));
    4765           0 :         return py_max_towers;
    4766             : }
    4767             : 
    4768          48 : static int py_epm_Map_in_set_max_towers(PyObject *py_obj, PyObject *value, void *closure)
    4769             : {
    4770          48 :         struct epm_Map *object = pytalloc_get_ptr(py_obj);
    4771          48 :         if (value == NULL) {
    4772           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.max_towers");
    4773           0 :                 return -1;
    4774             :         }
    4775             :         {
    4776          48 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.max_towers));
    4777          48 :                 if (PyLong_Check(value)) {
    4778           0 :                         unsigned long long test_var;
    4779          48 :                         test_var = PyLong_AsUnsignedLongLong(value);
    4780          48 :                         if (PyErr_Occurred() != NULL) {
    4781           0 :                                 return -1;
    4782             :                         }
    4783          48 :                         if (test_var > uint_max) {
    4784           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4785             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4786           0 :                                 return -1;
    4787             :                         }
    4788          48 :                         object->in.max_towers = test_var;
    4789             :                 } else {
    4790           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4791             :                           PyLong_Type.tp_name);
    4792           0 :                         return -1;
    4793             :                 }
    4794             :         }
    4795          48 :         return 0;
    4796             : }
    4797             : 
    4798          48 : static PyObject *py_epm_Map_out_get_num_towers(PyObject *obj, void *closure)
    4799             : {
    4800          48 :         struct epm_Map *object = pytalloc_get_ptr(obj);
    4801           0 :         PyObject *py_num_towers;
    4802          48 :         if (object->out.num_towers == NULL) {
    4803           0 :                 Py_RETURN_NONE;
    4804             :         }
    4805          48 :         py_num_towers = PyLong_FromUnsignedLongLong((uint32_t)(*object->out.num_towers));
    4806          48 :         return py_num_towers;
    4807             : }
    4808             : 
    4809           0 : static int py_epm_Map_out_set_num_towers(PyObject *py_obj, PyObject *value, void *closure)
    4810             : {
    4811           0 :         struct epm_Map *object = pytalloc_get_ptr(py_obj);
    4812           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.num_towers));
    4813           0 :         if (value == NULL) {
    4814           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.num_towers");
    4815           0 :                 return -1;
    4816             :         }
    4817           0 :         object->out.num_towers = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.num_towers);
    4818           0 :         if (object->out.num_towers == NULL) {
    4819           0 :                 PyErr_NoMemory();
    4820           0 :                 return -1;
    4821             :         }
    4822             :         {
    4823           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->out.num_towers));
    4824           0 :                 if (PyLong_Check(value)) {
    4825           0 :                         unsigned long long test_var;
    4826           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    4827           0 :                         if (PyErr_Occurred() != NULL) {
    4828           0 :                                 return -1;
    4829             :                         }
    4830           0 :                         if (test_var > uint_max) {
    4831           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4832             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4833           0 :                                 return -1;
    4834             :                         }
    4835           0 :                         *object->out.num_towers = test_var;
    4836             :                 } else {
    4837           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4838             :                           PyLong_Type.tp_name);
    4839           0 :                         return -1;
    4840             :                 }
    4841             :         }
    4842           0 :         return 0;
    4843             : }
    4844             : 
    4845          16 : static PyObject *py_epm_Map_out_get_towers(PyObject *obj, void *closure)
    4846             : {
    4847          16 :         struct epm_Map *object = pytalloc_get_ptr(obj);
    4848           0 :         PyObject *py_towers;
    4849          16 :         py_towers = PyList_New(*object->out.num_towers);
    4850          16 :         if (py_towers == NULL) {
    4851           0 :                 return NULL;
    4852             :         }
    4853             :         {
    4854             :                 int towers_cntr_0;
    4855          32 :                 for (towers_cntr_0 = 0; towers_cntr_0 < (*object->out.num_towers); towers_cntr_0++) {
    4856           0 :                         PyObject *py_towers_0;
    4857          16 :                         py_towers_0 = pytalloc_reference_ex(&epm_twr_p_t_Type, object->out.towers, &(object->out.towers)[towers_cntr_0]);
    4858          16 :                         PyList_SetItem(py_towers, towers_cntr_0, py_towers_0);
    4859             :                 }
    4860             :         }
    4861          16 :         return py_towers;
    4862             : }
    4863             : 
    4864           0 : static int py_epm_Map_out_set_towers(PyObject *py_obj, PyObject *value, void *closure)
    4865             : {
    4866           0 :         struct epm_Map *object = pytalloc_get_ptr(py_obj);
    4867           0 :         if (value == NULL) {
    4868           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.towers");
    4869           0 :                 return -1;
    4870             :         }
    4871           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
    4872             :         {
    4873           0 :                 int towers_cntr_0;
    4874           0 :                 object->out.towers = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.towers, PyList_GET_SIZE(value));
    4875           0 :                 if (!object->out.towers) { return -1; }
    4876           0 :                 talloc_set_name_const(object->out.towers, "ARRAY: object->out.towers");
    4877           0 :                 for (towers_cntr_0 = 0; towers_cntr_0 < PyList_GET_SIZE(value); towers_cntr_0++) {
    4878           0 :                         if (PyList_GET_ITEM(value, towers_cntr_0) == NULL) {
    4879           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->out.towers)[towers_cntr_0]");
    4880           0 :                                 return -1;
    4881             :                         }
    4882           0 :                         PY_CHECK_TYPE(&epm_twr_p_t_Type, PyList_GET_ITEM(value, towers_cntr_0), return -1;);
    4883           0 :                         if (talloc_reference(object->out.towers, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, towers_cntr_0))) == NULL) {
    4884           0 :                                 PyErr_NoMemory();
    4885           0 :                                 return -1;
    4886             :                         }
    4887           0 :                         (object->out.towers)[towers_cntr_0] = *(struct epm_twr_p_t *)pytalloc_get_ptr(PyList_GET_ITEM(value, towers_cntr_0));
    4888             :                 }
    4889             :         }
    4890           0 :         return 0;
    4891             : }
    4892             : 
    4893           0 : static PyObject *py_epm_Map_get_result(PyObject *obj, void *closure)
    4894             : {
    4895           0 :         struct epm_Map *object = pytalloc_get_ptr(obj);
    4896           0 :         PyObject *py_result;
    4897           0 :         py_result = PyLong_FromUnsignedLongLong((uint32_t)(object->out.result));
    4898           0 :         return py_result;
    4899             : }
    4900             : 
    4901           0 : static int py_epm_Map_set_result(PyObject *py_obj, PyObject *value, void *closure)
    4902             : {
    4903           0 :         struct epm_Map *object = pytalloc_get_ptr(py_obj);
    4904           0 :         if (value == NULL) {
    4905           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.result");
    4906           0 :                 return -1;
    4907             :         }
    4908             :         {
    4909           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->out.result));
    4910           0 :                 if (PyLong_Check(value)) {
    4911           0 :                         unsigned long long test_var;
    4912           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    4913           0 :                         if (PyErr_Occurred() != NULL) {
    4914           0 :                                 return -1;
    4915             :                         }
    4916           0 :                         if (test_var > uint_max) {
    4917           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4918             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4919           0 :                                 return -1;
    4920             :                         }
    4921           0 :                         object->out.result = test_var;
    4922             :                 } else {
    4923           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4924             :                           PyLong_Type.tp_name);
    4925           0 :                         return -1;
    4926             :                 }
    4927             :         }
    4928           0 :         return 0;
    4929             : }
    4930             : 
    4931             : static PyGetSetDef py_epm_Map_getsetters[] = {
    4932             :         {
    4933             :                 .name = discard_const_p(char, "in_object"),
    4934             :                 .get = py_epm_Map_in_get_object,
    4935             :                 .set = py_epm_Map_in_set_object,
    4936             :                 .doc = discard_const_p(char, "PIDL-generated element of base type GUID")
    4937             :         },
    4938             :         {
    4939             :                 .name = discard_const_p(char, "in_map_tower"),
    4940             :                 .get = py_epm_Map_in_get_map_tower,
    4941             :                 .set = py_epm_Map_in_set_map_tower,
    4942             :                 .doc = discard_const_p(char, "PIDL-generated element of base type epm_twr_t")
    4943             :         },
    4944             :         {
    4945             :                 .name = discard_const_p(char, "in_entry_handle"),
    4946             :                 .get = py_epm_Map_in_get_entry_handle,
    4947             :                 .set = py_epm_Map_in_set_entry_handle,
    4948             :                 .doc = discard_const_p(char, "PIDL-generated element of base type policy_handle")
    4949             :         },
    4950             :         {
    4951             :                 .name = discard_const_p(char, "out_entry_handle"),
    4952             :                 .get = py_epm_Map_out_get_entry_handle,
    4953             :                 .set = py_epm_Map_out_set_entry_handle,
    4954             :                 .doc = discard_const_p(char, "PIDL-generated element of base type policy_handle")
    4955             :         },
    4956             :         {
    4957             :                 .name = discard_const_p(char, "in_max_towers"),
    4958             :                 .get = py_epm_Map_in_get_max_towers,
    4959             :                 .set = py_epm_Map_in_set_max_towers,
    4960             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    4961             :         },
    4962             :         {
    4963             :                 .name = discard_const_p(char, "out_num_towers"),
    4964             :                 .get = py_epm_Map_out_get_num_towers,
    4965             :                 .set = py_epm_Map_out_set_num_towers,
    4966             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    4967             :         },
    4968             :         {
    4969             :                 .name = discard_const_p(char, "out_towers"),
    4970             :                 .get = py_epm_Map_out_get_towers,
    4971             :                 .set = py_epm_Map_out_set_towers,
    4972             :                 .doc = discard_const_p(char, "PIDL-generated element of base type epm_twr_p_t")
    4973             :         },
    4974             :         {
    4975             :                 .name = discard_const_p(char, "result"),
    4976             :                 .get = py_epm_Map_get_result,
    4977             :                 .set = py_epm_Map_set_result,
    4978             :                 .doc = discard_const_p(char, "PIDL-generated element of type uint32")
    4979             :         },
    4980             :         { .name = NULL }
    4981             : };
    4982             : 
    4983          48 : static PyObject *py_epm_Map_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    4984             : {
    4985          48 :         PyObject *self = pytalloc_new(struct epm_Map, type);
    4986          48 :         struct epm_Map *_self = (struct epm_Map *)pytalloc_get_ptr(self);
    4987          48 :         TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
    4988          48 :         _self->in.entry_handle = talloc_zero(mem_ctx, struct policy_handle);
    4989          48 :         _self->out.entry_handle = talloc_zero(mem_ctx, struct policy_handle);
    4990          48 :         _self->out.num_towers = talloc_zero(mem_ctx, uint32_t);
    4991          48 :         return self;
    4992             : }
    4993             : 
    4994          48 : static PyObject *py_epm_Map_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
    4995             : {
    4996             : 
    4997             : 
    4998          48 :         return PyLong_FromLong(3);
    4999             : }
    5000             : 
    5001          48 : static PyObject *py_epm_Map_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
    5002             : {
    5003          48 :         const struct ndr_interface_call *call = NULL;
    5004          48 :         struct epm_Map *object = pytalloc_get_ptr(py_obj);
    5005          48 :         PyObject *ret = NULL;
    5006          48 :         struct ndr_push *push = NULL;
    5007           0 :         DATA_BLOB blob;
    5008           0 :         enum ndr_err_code err;
    5009             : 
    5010          48 :         if (ndr_table_epmapper.num_calls < 4) {
    5011           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_epm_Map_ndr_pack");
    5012           0 :                 return NULL;
    5013             :         }
    5014          48 :         call = &ndr_table_epmapper.calls[3];
    5015             : 
    5016          48 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
    5017          48 :         if (push == NULL) {
    5018           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    5019           0 :                 return NULL;
    5020             :         }
    5021             : 
    5022          48 :         push->flags |= ndr_push_flags;
    5023             : 
    5024          48 :         err = call->ndr_push(push, ndr_inout_flags, object);
    5025          48 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    5026           0 :                 TALLOC_FREE(push);
    5027           0 :                 PyErr_SetNdrError(err);
    5028           0 :                 return NULL;
    5029             :         }
    5030          48 :         blob = ndr_push_blob(push);
    5031          48 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
    5032          48 :         TALLOC_FREE(push);
    5033          48 :         return ret;
    5034             : }
    5035             : 
    5036          48 : static PyObject *py_epm_Map_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    5037             : {
    5038          48 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    5039          48 :         PyObject *bigendian_obj = NULL;
    5040          48 :         PyObject *ndr64_obj = NULL;
    5041          48 :         libndr_flags ndr_push_flags = 0;
    5042             : 
    5043          48 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
    5044             :                 discard_const_p(char *, kwnames),
    5045             :                 &bigendian_obj,
    5046             :                 &ndr64_obj)) {
    5047           0 :                 return NULL;
    5048             :         }
    5049             : 
    5050          48 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    5051           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    5052             :         }
    5053          48 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    5054           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    5055             :         }
    5056             : 
    5057          48 :         return py_epm_Map_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
    5058             : }
    5059             : 
    5060           0 : static PyObject *py_epm_Map_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    5061             : {
    5062           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    5063           0 :         PyObject *bigendian_obj = NULL;
    5064           0 :         PyObject *ndr64_obj = NULL;
    5065           0 :         libndr_flags ndr_push_flags = 0;
    5066             : 
    5067           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
    5068             :                 discard_const_p(char *, kwnames),
    5069             :                 &bigendian_obj,
    5070             :                 &ndr64_obj)) {
    5071           0 :                 return NULL;
    5072             :         }
    5073             : 
    5074           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    5075           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    5076             :         }
    5077           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    5078           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    5079             :         }
    5080             : 
    5081           0 :         return py_epm_Map_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
    5082             : }
    5083             : 
    5084          48 : static PyObject *py_epm_Map_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
    5085             : {
    5086          48 :         const struct ndr_interface_call *call = NULL;
    5087          48 :         struct epm_Map *object = pytalloc_get_ptr(py_obj);
    5088          48 :         struct ndr_pull *pull = NULL;
    5089           0 :         enum ndr_err_code err;
    5090             : 
    5091          48 :         if (ndr_table_epmapper.num_calls < 4) {
    5092           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_epm_Map_ndr_unpack");
    5093           0 :                 return NULL;
    5094             :         }
    5095          48 :         call = &ndr_table_epmapper.calls[3];
    5096             : 
    5097          48 :         pull = ndr_pull_init_blob(blob, object);
    5098          48 :         if (pull == NULL) {
    5099           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    5100           0 :                 return NULL;
    5101             :         }
    5102             : 
    5103          48 :         pull->flags |= ndr_pull_flags;
    5104             : 
    5105          48 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
    5106          48 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    5107           0 :                 TALLOC_FREE(pull);
    5108           0 :                 PyErr_SetNdrError(err);
    5109           0 :                 return NULL;
    5110             :         }
    5111          48 :         if (!allow_remaining) {
    5112           0 :                 uint32_t highest_ofs;
    5113             : 
    5114          48 :                 if (pull->offset > pull->relative_highest_offset) {
    5115          48 :                         highest_ofs = pull->offset;
    5116             :                 } else {
    5117           0 :                         highest_ofs = pull->relative_highest_offset;
    5118             :                 }
    5119          48 :                 if (highest_ofs < pull->data_size) {
    5120           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
    5121             :                                 "not all bytes consumed ofs[%u] size[%u]",
    5122             :                                 highest_ofs, pull->data_size);
    5123           0 :                         TALLOC_FREE(pull);
    5124           0 :                         PyErr_SetNdrError(err);
    5125           0 :                         return NULL;
    5126             :                 }
    5127             :         }
    5128             : 
    5129          48 :         TALLOC_FREE(pull);
    5130          48 :         Py_RETURN_NONE;
    5131             : }
    5132             : 
    5133           0 : static PyObject *py_epm_Map_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    5134             : {
    5135           0 :         DATA_BLOB blob;
    5136           0 :         Py_ssize_t blob_length = 0;
    5137           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    5138           0 :         PyObject *bigendian_obj = NULL;
    5139           0 :         PyObject *ndr64_obj = NULL;
    5140           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    5141           0 :         PyObject *allow_remaining_obj = NULL;
    5142           0 :         bool allow_remaining = false;
    5143             : 
    5144           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
    5145             :                 discard_const_p(char *, kwnames),
    5146             :                 &blob.data, &blob_length,
    5147             :                 &bigendian_obj,
    5148             :                 &ndr64_obj,
    5149             :                 &allow_remaining_obj)) {
    5150           0 :                 return NULL;
    5151             :         }
    5152           0 :         blob.length = blob_length;
    5153             : 
    5154           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    5155           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    5156             :         }
    5157           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    5158           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    5159             :         }
    5160             : 
    5161           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    5162           0 :                 allow_remaining = true;
    5163             :         }
    5164             : 
    5165           0 :         return py_epm_Map_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
    5166             : }
    5167             : 
    5168          48 : static PyObject *py_epm_Map_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    5169             : {
    5170           0 :         DATA_BLOB blob;
    5171          48 :         Py_ssize_t blob_length = 0;
    5172          48 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    5173          48 :         PyObject *bigendian_obj = NULL;
    5174          48 :         PyObject *ndr64_obj = NULL;
    5175          48 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    5176          48 :         PyObject *allow_remaining_obj = NULL;
    5177          48 :         bool allow_remaining = false;
    5178             : 
    5179          48 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
    5180             :                 discard_const_p(char *, kwnames),
    5181             :                 &blob.data, &blob_length,
    5182             :                 &bigendian_obj,
    5183             :                 &ndr64_obj,
    5184             :                 &allow_remaining_obj)) {
    5185           0 :                 return NULL;
    5186             :         }
    5187          48 :         blob.length = blob_length;
    5188             : 
    5189          48 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    5190           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    5191             :         }
    5192          48 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    5193           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    5194             :         }
    5195             : 
    5196          48 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    5197           0 :                 allow_remaining = true;
    5198             :         }
    5199             : 
    5200          48 :         return py_epm_Map_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
    5201             : }
    5202             : 
    5203           0 : static PyObject *py_epm_Map_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
    5204             : {
    5205           0 :         const struct ndr_interface_call *call = NULL;
    5206           0 :         struct epm_Map *object = pytalloc_get_ptr(py_obj);
    5207           0 :         PyObject *ret;
    5208           0 :         char *retstr;
    5209             : 
    5210           0 :         if (ndr_table_epmapper.num_calls < 4) {
    5211           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_epm_Map_ndr_print");
    5212           0 :                 return NULL;
    5213             :         }
    5214           0 :         call = &ndr_table_epmapper.calls[3];
    5215             : 
    5216           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
    5217           0 :         ret = PyUnicode_FromString(retstr);
    5218           0 :         TALLOC_FREE(retstr);
    5219             : 
    5220           0 :         return ret;
    5221             : }
    5222             : 
    5223           0 : static PyObject *py_epm_Map_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    5224             : {
    5225           0 :         return py_epm_Map_ndr_print(py_obj, "epm_Map_in", NDR_IN);
    5226             : }
    5227             : 
    5228           0 : static PyObject *py_epm_Map_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    5229             : {
    5230           0 :         return py_epm_Map_ndr_print(py_obj, "epm_Map_out", NDR_OUT);
    5231             : }
    5232             : 
    5233             : static PyMethodDef py_epm_Map_methods[] = {
    5234             :         { "opnum", (PyCFunction)py_epm_Map_ndr_opnum, METH_NOARGS|METH_CLASS,
    5235             :                 "epmapper.epm_Map.opnum() -> 3 (0x03) " },
    5236             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_Map_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
    5237             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
    5238             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_Map_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
    5239             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
    5240             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_Map_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
    5241             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
    5242             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_Map_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
    5243             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
    5244             :         { "__ndr_print_in__", (PyCFunction)py_epm_Map_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
    5245             :         { "__ndr_print_out__", (PyCFunction)py_epm_Map_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
    5246             :         { NULL, NULL, 0, NULL }
    5247             : };
    5248             : 
    5249             : 
    5250             : static PyTypeObject epm_Map_Type = {
    5251             :         PyVarObject_HEAD_INIT(NULL, 0)
    5252             :         .tp_name = "epmapper.epm_Map",
    5253             :         .tp_getset = py_epm_Map_getsetters,
    5254             :         .tp_methods = py_epm_Map_methods,
    5255             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    5256             :         .tp_new = py_epm_Map_new,
    5257             : };
    5258             : 
    5259           0 : static bool pack_py_epm_Map_args_in(PyObject *args, PyObject *kwargs, struct epm_Map *r)
    5260             : {
    5261           0 :         PyObject *py_object;
    5262           0 :         PyObject *py_map_tower;
    5263           0 :         PyObject *py_entry_handle;
    5264           0 :         PyObject *py_max_towers;
    5265           0 :         const char *kwnames[] = {
    5266             :                 "object", "map_tower", "entry_handle", "max_towers", NULL
    5267             :         };
    5268             : 
    5269           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:epm_Map", discard_const_p(char *, kwnames), &py_object, &py_map_tower, &py_entry_handle, &py_max_towers)) {
    5270           0 :                 return false;
    5271             :         }
    5272             : 
    5273           0 :         if (py_object == NULL) {
    5274           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.object");
    5275           0 :                 return false;
    5276             :         }
    5277           0 :         if (py_object == Py_None) {
    5278           0 :                 r->in.object = NULL;
    5279             :         } else {
    5280           0 :                 r->in.object = NULL;
    5281           0 :                 PY_CHECK_TYPE(GUID_Type, py_object, return false;);
    5282           0 :                 if (talloc_reference(r, pytalloc_get_mem_ctx(py_object)) == NULL) {
    5283           0 :                         PyErr_NoMemory();
    5284           0 :                         return false;
    5285             :                 }
    5286           0 :                 r->in.object = (struct GUID *)pytalloc_get_ptr(py_object);
    5287             :         }
    5288           0 :         if (py_map_tower == NULL) {
    5289           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.map_tower");
    5290           0 :                 return false;
    5291             :         }
    5292           0 :         if (py_map_tower == Py_None) {
    5293           0 :                 r->in.map_tower = NULL;
    5294             :         } else {
    5295           0 :                 r->in.map_tower = NULL;
    5296           0 :                 PY_CHECK_TYPE(&epm_twr_t_Type, py_map_tower, return false;);
    5297           0 :                 if (talloc_reference(r, pytalloc_get_mem_ctx(py_map_tower)) == NULL) {
    5298           0 :                         PyErr_NoMemory();
    5299           0 :                         return false;
    5300             :                 }
    5301           0 :                 r->in.map_tower = (struct epm_twr_t *)pytalloc_get_ptr(py_map_tower);
    5302             :         }
    5303           0 :         if (py_entry_handle == NULL) {
    5304           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.entry_handle");
    5305           0 :                 return false;
    5306             :         }
    5307           0 :         r->in.entry_handle = talloc_ptrtype(r, r->in.entry_handle);
    5308           0 :         if (r->in.entry_handle == NULL) {
    5309           0 :                 PyErr_NoMemory();
    5310           0 :                 return false;
    5311             :         }
    5312           0 :         PY_CHECK_TYPE(policy_handle_Type, py_entry_handle, return false;);
    5313           0 :         if (talloc_reference(r, pytalloc_get_mem_ctx(py_entry_handle)) == NULL) {
    5314           0 :                 PyErr_NoMemory();
    5315           0 :                 return false;
    5316             :         }
    5317           0 :         r->in.entry_handle = (struct policy_handle *)pytalloc_get_ptr(py_entry_handle);
    5318           0 :         if (py_max_towers == NULL) {
    5319           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.max_towers");
    5320           0 :                 return false;
    5321             :         }
    5322             :         {
    5323           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.max_towers));
    5324           0 :                 if (PyLong_Check(py_max_towers)) {
    5325           0 :                         unsigned long long test_var;
    5326           0 :                         test_var = PyLong_AsUnsignedLongLong(py_max_towers);
    5327           0 :                         if (PyErr_Occurred() != NULL) {
    5328           0 :                                 return false;
    5329             :                         }
    5330           0 :                         if (test_var > uint_max) {
    5331           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    5332             :                                   PyLong_Type.tp_name, uint_max, test_var);
    5333           0 :                                 return false;
    5334             :                         }
    5335           0 :                         r->in.max_towers = test_var;
    5336             :                 } else {
    5337           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    5338             :                           PyLong_Type.tp_name);
    5339           0 :                         return false;
    5340             :                 }
    5341             :         }
    5342           0 :         return true;
    5343             : }
    5344             : 
    5345           0 : static PyObject *unpack_py_epm_Map_args_out(struct epm_Map *r)
    5346             : {
    5347           0 :         PyObject *result;
    5348           0 :         PyObject *py_entry_handle;
    5349           0 :         PyObject *py_towers;
    5350           0 :         result = PyTuple_New(3);
    5351           0 :         py_entry_handle = pytalloc_reference_ex(policy_handle_Type, r->out.entry_handle, r->out.entry_handle);
    5352           0 :         PyTuple_SetItem(result, 0, py_entry_handle);
    5353           0 :         py_towers = PyList_New(*r->out.num_towers);
    5354           0 :         if (py_towers == NULL) {
    5355           0 :                 return NULL;
    5356             :         }
    5357             :         {
    5358             :                 int towers_cntr_0;
    5359           0 :                 for (towers_cntr_0 = 0; towers_cntr_0 < (*r->out.num_towers); towers_cntr_0++) {
    5360           0 :                         PyObject *py_towers_0;
    5361           0 :                         py_towers_0 = pytalloc_reference_ex(&epm_twr_p_t_Type, r->out.towers, &(r->out.towers)[towers_cntr_0]);
    5362           0 :                         PyList_SetItem(py_towers, towers_cntr_0, py_towers_0);
    5363             :                 }
    5364             :         }
    5365           0 :         PyTuple_SetItem(result, 1, py_towers);
    5366           0 :         PyTuple_SetItem(result, 2, PyLong_FromUnsignedLongLong((uint32_t)(r->out.result)));
    5367           0 :         return result;
    5368             : }
    5369             : 
    5370             : 
    5371           0 : static PyObject *py_epm_LookupHandleFree_in_get_entry_handle(PyObject *obj, void *closure)
    5372             : {
    5373           0 :         struct epm_LookupHandleFree *object = pytalloc_get_ptr(obj);
    5374           0 :         PyObject *py_entry_handle;
    5375           0 :         if (object->in.entry_handle == NULL) {
    5376           0 :                 Py_RETURN_NONE;
    5377             :         }
    5378           0 :         py_entry_handle = pytalloc_reference_ex(policy_handle_Type, object->in.entry_handle, object->in.entry_handle);
    5379           0 :         return py_entry_handle;
    5380             : }
    5381             : 
    5382           0 : static int py_epm_LookupHandleFree_in_set_entry_handle(PyObject *py_obj, PyObject *value, void *closure)
    5383             : {
    5384           0 :         struct epm_LookupHandleFree *object = pytalloc_get_ptr(py_obj);
    5385           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.entry_handle));
    5386           0 :         if (value == NULL) {
    5387           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.entry_handle");
    5388           0 :                 return -1;
    5389             :         }
    5390           0 :         object->in.entry_handle = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.entry_handle);
    5391           0 :         if (object->in.entry_handle == NULL) {
    5392           0 :                 PyErr_NoMemory();
    5393           0 :                 return -1;
    5394             :         }
    5395           0 :         PY_CHECK_TYPE(policy_handle_Type, value, return -1;);
    5396           0 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    5397           0 :                 PyErr_NoMemory();
    5398           0 :                 return -1;
    5399             :         }
    5400           0 :         object->in.entry_handle = (struct policy_handle *)pytalloc_get_ptr(value);
    5401           0 :         return 0;
    5402             : }
    5403             : 
    5404           0 : static PyObject *py_epm_LookupHandleFree_out_get_entry_handle(PyObject *obj, void *closure)
    5405             : {
    5406           0 :         struct epm_LookupHandleFree *object = pytalloc_get_ptr(obj);
    5407           0 :         PyObject *py_entry_handle;
    5408           0 :         if (object->out.entry_handle == NULL) {
    5409           0 :                 Py_RETURN_NONE;
    5410             :         }
    5411           0 :         py_entry_handle = pytalloc_reference_ex(policy_handle_Type, object->out.entry_handle, object->out.entry_handle);
    5412           0 :         return py_entry_handle;
    5413             : }
    5414             : 
    5415           0 : static int py_epm_LookupHandleFree_out_set_entry_handle(PyObject *py_obj, PyObject *value, void *closure)
    5416             : {
    5417           0 :         struct epm_LookupHandleFree *object = pytalloc_get_ptr(py_obj);
    5418           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.entry_handle));
    5419           0 :         if (value == NULL) {
    5420           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.entry_handle");
    5421           0 :                 return -1;
    5422             :         }
    5423           0 :         object->out.entry_handle = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.entry_handle);
    5424           0 :         if (object->out.entry_handle == NULL) {
    5425           0 :                 PyErr_NoMemory();
    5426           0 :                 return -1;
    5427             :         }
    5428           0 :         PY_CHECK_TYPE(policy_handle_Type, value, return -1;);
    5429           0 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    5430           0 :                 PyErr_NoMemory();
    5431           0 :                 return -1;
    5432             :         }
    5433           0 :         object->out.entry_handle = (struct policy_handle *)pytalloc_get_ptr(value);
    5434           0 :         return 0;
    5435             : }
    5436             : 
    5437           0 : static PyObject *py_epm_LookupHandleFree_get_result(PyObject *obj, void *closure)
    5438             : {
    5439           0 :         struct epm_LookupHandleFree *object = pytalloc_get_ptr(obj);
    5440           0 :         PyObject *py_result;
    5441           0 :         py_result = PyLong_FromUnsignedLongLong((uint32_t)(object->out.result));
    5442           0 :         return py_result;
    5443             : }
    5444             : 
    5445           0 : static int py_epm_LookupHandleFree_set_result(PyObject *py_obj, PyObject *value, void *closure)
    5446             : {
    5447           0 :         struct epm_LookupHandleFree *object = pytalloc_get_ptr(py_obj);
    5448           0 :         if (value == NULL) {
    5449           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.result");
    5450           0 :                 return -1;
    5451             :         }
    5452             :         {
    5453           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->out.result));
    5454           0 :                 if (PyLong_Check(value)) {
    5455           0 :                         unsigned long long test_var;
    5456           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    5457           0 :                         if (PyErr_Occurred() != NULL) {
    5458           0 :                                 return -1;
    5459             :                         }
    5460           0 :                         if (test_var > uint_max) {
    5461           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    5462             :                                   PyLong_Type.tp_name, uint_max, test_var);
    5463           0 :                                 return -1;
    5464             :                         }
    5465           0 :                         object->out.result = test_var;
    5466             :                 } else {
    5467           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    5468             :                           PyLong_Type.tp_name);
    5469           0 :                         return -1;
    5470             :                 }
    5471             :         }
    5472           0 :         return 0;
    5473             : }
    5474             : 
    5475             : static PyGetSetDef py_epm_LookupHandleFree_getsetters[] = {
    5476             :         {
    5477             :                 .name = discard_const_p(char, "in_entry_handle"),
    5478             :                 .get = py_epm_LookupHandleFree_in_get_entry_handle,
    5479             :                 .set = py_epm_LookupHandleFree_in_set_entry_handle,
    5480             :                 .doc = discard_const_p(char, "PIDL-generated element of base type policy_handle")
    5481             :         },
    5482             :         {
    5483             :                 .name = discard_const_p(char, "out_entry_handle"),
    5484             :                 .get = py_epm_LookupHandleFree_out_get_entry_handle,
    5485             :                 .set = py_epm_LookupHandleFree_out_set_entry_handle,
    5486             :                 .doc = discard_const_p(char, "PIDL-generated element of base type policy_handle")
    5487             :         },
    5488             :         {
    5489             :                 .name = discard_const_p(char, "result"),
    5490             :                 .get = py_epm_LookupHandleFree_get_result,
    5491             :                 .set = py_epm_LookupHandleFree_set_result,
    5492             :                 .doc = discard_const_p(char, "PIDL-generated element of type uint32")
    5493             :         },
    5494             :         { .name = NULL }
    5495             : };
    5496             : 
    5497           0 : static PyObject *py_epm_LookupHandleFree_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    5498             : {
    5499           0 :         PyObject *self = pytalloc_new(struct epm_LookupHandleFree, type);
    5500           0 :         struct epm_LookupHandleFree *_self = (struct epm_LookupHandleFree *)pytalloc_get_ptr(self);
    5501           0 :         TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
    5502           0 :         _self->in.entry_handle = talloc_zero(mem_ctx, struct policy_handle);
    5503           0 :         _self->out.entry_handle = talloc_zero(mem_ctx, struct policy_handle);
    5504           0 :         return self;
    5505             : }
    5506             : 
    5507           0 : static PyObject *py_epm_LookupHandleFree_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
    5508             : {
    5509             : 
    5510             : 
    5511           0 :         return PyLong_FromLong(4);
    5512             : }
    5513             : 
    5514           0 : static PyObject *py_epm_LookupHandleFree_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
    5515             : {
    5516           0 :         const struct ndr_interface_call *call = NULL;
    5517           0 :         struct epm_LookupHandleFree *object = pytalloc_get_ptr(py_obj);
    5518           0 :         PyObject *ret = NULL;
    5519           0 :         struct ndr_push *push = NULL;
    5520           0 :         DATA_BLOB blob;
    5521           0 :         enum ndr_err_code err;
    5522             : 
    5523           0 :         if (ndr_table_epmapper.num_calls < 5) {
    5524           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_epm_LookupHandleFree_ndr_pack");
    5525           0 :                 return NULL;
    5526             :         }
    5527           0 :         call = &ndr_table_epmapper.calls[4];
    5528             : 
    5529           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
    5530           0 :         if (push == NULL) {
    5531           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    5532           0 :                 return NULL;
    5533             :         }
    5534             : 
    5535           0 :         push->flags |= ndr_push_flags;
    5536             : 
    5537           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
    5538           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    5539           0 :                 TALLOC_FREE(push);
    5540           0 :                 PyErr_SetNdrError(err);
    5541           0 :                 return NULL;
    5542             :         }
    5543           0 :         blob = ndr_push_blob(push);
    5544           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
    5545           0 :         TALLOC_FREE(push);
    5546           0 :         return ret;
    5547             : }
    5548             : 
    5549           0 : static PyObject *py_epm_LookupHandleFree_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    5550             : {
    5551           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    5552           0 :         PyObject *bigendian_obj = NULL;
    5553           0 :         PyObject *ndr64_obj = NULL;
    5554           0 :         libndr_flags ndr_push_flags = 0;
    5555             : 
    5556           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
    5557             :                 discard_const_p(char *, kwnames),
    5558             :                 &bigendian_obj,
    5559             :                 &ndr64_obj)) {
    5560           0 :                 return NULL;
    5561             :         }
    5562             : 
    5563           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    5564           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    5565             :         }
    5566           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    5567           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    5568             :         }
    5569             : 
    5570           0 :         return py_epm_LookupHandleFree_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
    5571             : }
    5572             : 
    5573           0 : static PyObject *py_epm_LookupHandleFree_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    5574             : {
    5575           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    5576           0 :         PyObject *bigendian_obj = NULL;
    5577           0 :         PyObject *ndr64_obj = NULL;
    5578           0 :         libndr_flags ndr_push_flags = 0;
    5579             : 
    5580           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
    5581             :                 discard_const_p(char *, kwnames),
    5582             :                 &bigendian_obj,
    5583             :                 &ndr64_obj)) {
    5584           0 :                 return NULL;
    5585             :         }
    5586             : 
    5587           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    5588           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    5589             :         }
    5590           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    5591           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    5592             :         }
    5593             : 
    5594           0 :         return py_epm_LookupHandleFree_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
    5595             : }
    5596             : 
    5597           0 : static PyObject *py_epm_LookupHandleFree_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
    5598             : {
    5599           0 :         const struct ndr_interface_call *call = NULL;
    5600           0 :         struct epm_LookupHandleFree *object = pytalloc_get_ptr(py_obj);
    5601           0 :         struct ndr_pull *pull = NULL;
    5602           0 :         enum ndr_err_code err;
    5603             : 
    5604           0 :         if (ndr_table_epmapper.num_calls < 5) {
    5605           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_epm_LookupHandleFree_ndr_unpack");
    5606           0 :                 return NULL;
    5607             :         }
    5608           0 :         call = &ndr_table_epmapper.calls[4];
    5609             : 
    5610           0 :         pull = ndr_pull_init_blob(blob, object);
    5611           0 :         if (pull == NULL) {
    5612           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    5613           0 :                 return NULL;
    5614             :         }
    5615             : 
    5616           0 :         pull->flags |= ndr_pull_flags;
    5617             : 
    5618           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
    5619           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    5620           0 :                 TALLOC_FREE(pull);
    5621           0 :                 PyErr_SetNdrError(err);
    5622           0 :                 return NULL;
    5623             :         }
    5624           0 :         if (!allow_remaining) {
    5625           0 :                 uint32_t highest_ofs;
    5626             : 
    5627           0 :                 if (pull->offset > pull->relative_highest_offset) {
    5628           0 :                         highest_ofs = pull->offset;
    5629             :                 } else {
    5630           0 :                         highest_ofs = pull->relative_highest_offset;
    5631             :                 }
    5632           0 :                 if (highest_ofs < pull->data_size) {
    5633           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
    5634             :                                 "not all bytes consumed ofs[%u] size[%u]",
    5635             :                                 highest_ofs, pull->data_size);
    5636           0 :                         TALLOC_FREE(pull);
    5637           0 :                         PyErr_SetNdrError(err);
    5638           0 :                         return NULL;
    5639             :                 }
    5640             :         }
    5641             : 
    5642           0 :         TALLOC_FREE(pull);
    5643           0 :         Py_RETURN_NONE;
    5644             : }
    5645             : 
    5646           0 : static PyObject *py_epm_LookupHandleFree_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    5647             : {
    5648           0 :         DATA_BLOB blob;
    5649           0 :         Py_ssize_t blob_length = 0;
    5650           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    5651           0 :         PyObject *bigendian_obj = NULL;
    5652           0 :         PyObject *ndr64_obj = NULL;
    5653           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    5654           0 :         PyObject *allow_remaining_obj = NULL;
    5655           0 :         bool allow_remaining = false;
    5656             : 
    5657           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
    5658             :                 discard_const_p(char *, kwnames),
    5659             :                 &blob.data, &blob_length,
    5660             :                 &bigendian_obj,
    5661             :                 &ndr64_obj,
    5662             :                 &allow_remaining_obj)) {
    5663           0 :                 return NULL;
    5664             :         }
    5665           0 :         blob.length = blob_length;
    5666             : 
    5667           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    5668           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    5669             :         }
    5670           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    5671           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    5672             :         }
    5673             : 
    5674           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    5675           0 :                 allow_remaining = true;
    5676             :         }
    5677             : 
    5678           0 :         return py_epm_LookupHandleFree_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
    5679             : }
    5680             : 
    5681           0 : static PyObject *py_epm_LookupHandleFree_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    5682             : {
    5683           0 :         DATA_BLOB blob;
    5684           0 :         Py_ssize_t blob_length = 0;
    5685           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    5686           0 :         PyObject *bigendian_obj = NULL;
    5687           0 :         PyObject *ndr64_obj = NULL;
    5688           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    5689           0 :         PyObject *allow_remaining_obj = NULL;
    5690           0 :         bool allow_remaining = false;
    5691             : 
    5692           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
    5693             :                 discard_const_p(char *, kwnames),
    5694             :                 &blob.data, &blob_length,
    5695             :                 &bigendian_obj,
    5696             :                 &ndr64_obj,
    5697             :                 &allow_remaining_obj)) {
    5698           0 :                 return NULL;
    5699             :         }
    5700           0 :         blob.length = blob_length;
    5701             : 
    5702           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    5703           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    5704             :         }
    5705           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    5706           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    5707             :         }
    5708             : 
    5709           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    5710           0 :                 allow_remaining = true;
    5711             :         }
    5712             : 
    5713           0 :         return py_epm_LookupHandleFree_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
    5714             : }
    5715             : 
    5716           0 : static PyObject *py_epm_LookupHandleFree_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
    5717             : {
    5718           0 :         const struct ndr_interface_call *call = NULL;
    5719           0 :         struct epm_LookupHandleFree *object = pytalloc_get_ptr(py_obj);
    5720           0 :         PyObject *ret;
    5721           0 :         char *retstr;
    5722             : 
    5723           0 :         if (ndr_table_epmapper.num_calls < 5) {
    5724           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_epm_LookupHandleFree_ndr_print");
    5725           0 :                 return NULL;
    5726             :         }
    5727           0 :         call = &ndr_table_epmapper.calls[4];
    5728             : 
    5729           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
    5730           0 :         ret = PyUnicode_FromString(retstr);
    5731           0 :         TALLOC_FREE(retstr);
    5732             : 
    5733           0 :         return ret;
    5734             : }
    5735             : 
    5736           0 : static PyObject *py_epm_LookupHandleFree_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    5737             : {
    5738           0 :         return py_epm_LookupHandleFree_ndr_print(py_obj, "epm_LookupHandleFree_in", NDR_IN);
    5739             : }
    5740             : 
    5741           0 : static PyObject *py_epm_LookupHandleFree_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    5742             : {
    5743           0 :         return py_epm_LookupHandleFree_ndr_print(py_obj, "epm_LookupHandleFree_out", NDR_OUT);
    5744             : }
    5745             : 
    5746             : static PyMethodDef py_epm_LookupHandleFree_methods[] = {
    5747             :         { "opnum", (PyCFunction)py_epm_LookupHandleFree_ndr_opnum, METH_NOARGS|METH_CLASS,
    5748             :                 "epmapper.epm_LookupHandleFree.opnum() -> 4 (0x04) " },
    5749             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_LookupHandleFree_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
    5750             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
    5751             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_LookupHandleFree_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
    5752             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
    5753             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_LookupHandleFree_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
    5754             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
    5755             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_LookupHandleFree_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
    5756             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
    5757             :         { "__ndr_print_in__", (PyCFunction)py_epm_LookupHandleFree_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
    5758             :         { "__ndr_print_out__", (PyCFunction)py_epm_LookupHandleFree_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
    5759             :         { NULL, NULL, 0, NULL }
    5760             : };
    5761             : 
    5762             : 
    5763             : static PyTypeObject epm_LookupHandleFree_Type = {
    5764             :         PyVarObject_HEAD_INIT(NULL, 0)
    5765             :         .tp_name = "epmapper.epm_LookupHandleFree",
    5766             :         .tp_getset = py_epm_LookupHandleFree_getsetters,
    5767             :         .tp_methods = py_epm_LookupHandleFree_methods,
    5768             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    5769             :         .tp_new = py_epm_LookupHandleFree_new,
    5770             : };
    5771             : 
    5772           0 : static bool pack_py_epm_LookupHandleFree_args_in(PyObject *args, PyObject *kwargs, struct epm_LookupHandleFree *r)
    5773             : {
    5774           0 :         PyObject *py_entry_handle;
    5775           0 :         const char *kwnames[] = {
    5776             :                 "entry_handle", NULL
    5777             :         };
    5778             : 
    5779           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:epm_LookupHandleFree", discard_const_p(char *, kwnames), &py_entry_handle)) {
    5780           0 :                 return false;
    5781             :         }
    5782             : 
    5783           0 :         if (py_entry_handle == NULL) {
    5784           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.entry_handle");
    5785           0 :                 return false;
    5786             :         }
    5787           0 :         r->in.entry_handle = talloc_ptrtype(r, r->in.entry_handle);
    5788           0 :         if (r->in.entry_handle == NULL) {
    5789           0 :                 PyErr_NoMemory();
    5790           0 :                 return false;
    5791             :         }
    5792           0 :         PY_CHECK_TYPE(policy_handle_Type, py_entry_handle, return false;);
    5793           0 :         if (talloc_reference(r, pytalloc_get_mem_ctx(py_entry_handle)) == NULL) {
    5794           0 :                 PyErr_NoMemory();
    5795           0 :                 return false;
    5796             :         }
    5797           0 :         r->in.entry_handle = (struct policy_handle *)pytalloc_get_ptr(py_entry_handle);
    5798           0 :         return true;
    5799             : }
    5800             : 
    5801           0 : static PyObject *unpack_py_epm_LookupHandleFree_args_out(struct epm_LookupHandleFree *r)
    5802             : {
    5803           0 :         PyObject *result;
    5804           0 :         PyObject *py_entry_handle;
    5805           0 :         result = PyTuple_New(2);
    5806           0 :         py_entry_handle = pytalloc_reference_ex(policy_handle_Type, r->out.entry_handle, r->out.entry_handle);
    5807           0 :         PyTuple_SetItem(result, 0, py_entry_handle);
    5808           0 :         PyTuple_SetItem(result, 1, PyLong_FromUnsignedLongLong((uint32_t)(r->out.result)));
    5809           0 :         return result;
    5810             : }
    5811             : 
    5812             : 
    5813           0 : static PyObject *py_epm_InqObject_in_get_epm_object(PyObject *obj, void *closure)
    5814             : {
    5815           0 :         struct epm_InqObject *object = pytalloc_get_ptr(obj);
    5816           0 :         PyObject *py_epm_object;
    5817           0 :         if (object->in.epm_object == NULL) {
    5818           0 :                 Py_RETURN_NONE;
    5819             :         }
    5820           0 :         py_epm_object = pytalloc_reference_ex(GUID_Type, object->in.epm_object, object->in.epm_object);
    5821           0 :         return py_epm_object;
    5822             : }
    5823             : 
    5824           0 : static int py_epm_InqObject_in_set_epm_object(PyObject *py_obj, PyObject *value, void *closure)
    5825             : {
    5826           0 :         struct epm_InqObject *object = pytalloc_get_ptr(py_obj);
    5827           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.epm_object));
    5828           0 :         if (value == NULL) {
    5829           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.epm_object");
    5830           0 :                 return -1;
    5831             :         }
    5832           0 :         object->in.epm_object = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.epm_object);
    5833           0 :         if (object->in.epm_object == NULL) {
    5834           0 :                 PyErr_NoMemory();
    5835           0 :                 return -1;
    5836             :         }
    5837           0 :         PY_CHECK_TYPE(GUID_Type, value, return -1;);
    5838           0 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    5839           0 :                 PyErr_NoMemory();
    5840           0 :                 return -1;
    5841             :         }
    5842           0 :         object->in.epm_object = (struct GUID *)pytalloc_get_ptr(value);
    5843           0 :         return 0;
    5844             : }
    5845             : 
    5846           0 : static PyObject *py_epm_InqObject_get_result(PyObject *obj, void *closure)
    5847             : {
    5848           0 :         struct epm_InqObject *object = pytalloc_get_ptr(obj);
    5849           0 :         PyObject *py_result;
    5850           0 :         py_result = PyLong_FromUnsignedLongLong((uint32_t)(object->out.result));
    5851           0 :         return py_result;
    5852             : }
    5853             : 
    5854           0 : static int py_epm_InqObject_set_result(PyObject *py_obj, PyObject *value, void *closure)
    5855             : {
    5856           0 :         struct epm_InqObject *object = pytalloc_get_ptr(py_obj);
    5857           0 :         if (value == NULL) {
    5858           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.result");
    5859           0 :                 return -1;
    5860             :         }
    5861             :         {
    5862           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->out.result));
    5863           0 :                 if (PyLong_Check(value)) {
    5864           0 :                         unsigned long long test_var;
    5865           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    5866           0 :                         if (PyErr_Occurred() != NULL) {
    5867           0 :                                 return -1;
    5868             :                         }
    5869           0 :                         if (test_var > uint_max) {
    5870           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    5871             :                                   PyLong_Type.tp_name, uint_max, test_var);
    5872           0 :                                 return -1;
    5873             :                         }
    5874           0 :                         object->out.result = test_var;
    5875             :                 } else {
    5876           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    5877             :                           PyLong_Type.tp_name);
    5878           0 :                         return -1;
    5879             :                 }
    5880             :         }
    5881           0 :         return 0;
    5882             : }
    5883             : 
    5884             : static PyGetSetDef py_epm_InqObject_getsetters[] = {
    5885             :         {
    5886             :                 .name = discard_const_p(char, "in_epm_object"),
    5887             :                 .get = py_epm_InqObject_in_get_epm_object,
    5888             :                 .set = py_epm_InqObject_in_set_epm_object,
    5889             :                 .doc = discard_const_p(char, "PIDL-generated element of base type GUID")
    5890             :         },
    5891             :         {
    5892             :                 .name = discard_const_p(char, "result"),
    5893             :                 .get = py_epm_InqObject_get_result,
    5894             :                 .set = py_epm_InqObject_set_result,
    5895             :                 .doc = discard_const_p(char, "PIDL-generated element of type uint32")
    5896             :         },
    5897             :         { .name = NULL }
    5898             : };
    5899             : 
    5900           0 : static PyObject *py_epm_InqObject_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    5901             : {
    5902           0 :         PyObject *self = pytalloc_new(struct epm_InqObject, type);
    5903           0 :         struct epm_InqObject *_self = (struct epm_InqObject *)pytalloc_get_ptr(self);
    5904           0 :         TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
    5905           0 :         _self->in.epm_object = talloc_zero(mem_ctx, struct GUID);
    5906           0 :         return self;
    5907             : }
    5908             : 
    5909           0 : static PyObject *py_epm_InqObject_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
    5910             : {
    5911             : 
    5912             : 
    5913           0 :         return PyLong_FromLong(5);
    5914             : }
    5915             : 
    5916           0 : static PyObject *py_epm_InqObject_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
    5917             : {
    5918           0 :         const struct ndr_interface_call *call = NULL;
    5919           0 :         struct epm_InqObject *object = pytalloc_get_ptr(py_obj);
    5920           0 :         PyObject *ret = NULL;
    5921           0 :         struct ndr_push *push = NULL;
    5922           0 :         DATA_BLOB blob;
    5923           0 :         enum ndr_err_code err;
    5924             : 
    5925           0 :         if (ndr_table_epmapper.num_calls < 6) {
    5926           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_epm_InqObject_ndr_pack");
    5927           0 :                 return NULL;
    5928             :         }
    5929           0 :         call = &ndr_table_epmapper.calls[5];
    5930             : 
    5931           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
    5932           0 :         if (push == NULL) {
    5933           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    5934           0 :                 return NULL;
    5935             :         }
    5936             : 
    5937           0 :         push->flags |= ndr_push_flags;
    5938             : 
    5939           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
    5940           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    5941           0 :                 TALLOC_FREE(push);
    5942           0 :                 PyErr_SetNdrError(err);
    5943           0 :                 return NULL;
    5944             :         }
    5945           0 :         blob = ndr_push_blob(push);
    5946           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
    5947           0 :         TALLOC_FREE(push);
    5948           0 :         return ret;
    5949             : }
    5950             : 
    5951           0 : static PyObject *py_epm_InqObject_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    5952             : {
    5953           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    5954           0 :         PyObject *bigendian_obj = NULL;
    5955           0 :         PyObject *ndr64_obj = NULL;
    5956           0 :         libndr_flags ndr_push_flags = 0;
    5957             : 
    5958           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
    5959             :                 discard_const_p(char *, kwnames),
    5960             :                 &bigendian_obj,
    5961             :                 &ndr64_obj)) {
    5962           0 :                 return NULL;
    5963             :         }
    5964             : 
    5965           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    5966           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    5967             :         }
    5968           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    5969           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    5970             :         }
    5971             : 
    5972           0 :         return py_epm_InqObject_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
    5973             : }
    5974             : 
    5975           0 : static PyObject *py_epm_InqObject_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    5976             : {
    5977           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    5978           0 :         PyObject *bigendian_obj = NULL;
    5979           0 :         PyObject *ndr64_obj = NULL;
    5980           0 :         libndr_flags ndr_push_flags = 0;
    5981             : 
    5982           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
    5983             :                 discard_const_p(char *, kwnames),
    5984             :                 &bigendian_obj,
    5985             :                 &ndr64_obj)) {
    5986           0 :                 return NULL;
    5987             :         }
    5988             : 
    5989           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    5990           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    5991             :         }
    5992           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    5993           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    5994             :         }
    5995             : 
    5996           0 :         return py_epm_InqObject_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
    5997             : }
    5998             : 
    5999           0 : static PyObject *py_epm_InqObject_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
    6000             : {
    6001           0 :         const struct ndr_interface_call *call = NULL;
    6002           0 :         struct epm_InqObject *object = pytalloc_get_ptr(py_obj);
    6003           0 :         struct ndr_pull *pull = NULL;
    6004           0 :         enum ndr_err_code err;
    6005             : 
    6006           0 :         if (ndr_table_epmapper.num_calls < 6) {
    6007           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_epm_InqObject_ndr_unpack");
    6008           0 :                 return NULL;
    6009             :         }
    6010           0 :         call = &ndr_table_epmapper.calls[5];
    6011             : 
    6012           0 :         pull = ndr_pull_init_blob(blob, object);
    6013           0 :         if (pull == NULL) {
    6014           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    6015           0 :                 return NULL;
    6016             :         }
    6017             : 
    6018           0 :         pull->flags |= ndr_pull_flags;
    6019             : 
    6020           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
    6021           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    6022           0 :                 TALLOC_FREE(pull);
    6023           0 :                 PyErr_SetNdrError(err);
    6024           0 :                 return NULL;
    6025             :         }
    6026           0 :         if (!allow_remaining) {
    6027           0 :                 uint32_t highest_ofs;
    6028             : 
    6029           0 :                 if (pull->offset > pull->relative_highest_offset) {
    6030           0 :                         highest_ofs = pull->offset;
    6031             :                 } else {
    6032           0 :                         highest_ofs = pull->relative_highest_offset;
    6033             :                 }
    6034           0 :                 if (highest_ofs < pull->data_size) {
    6035           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
    6036             :                                 "not all bytes consumed ofs[%u] size[%u]",
    6037             :                                 highest_ofs, pull->data_size);
    6038           0 :                         TALLOC_FREE(pull);
    6039           0 :                         PyErr_SetNdrError(err);
    6040           0 :                         return NULL;
    6041             :                 }
    6042             :         }
    6043             : 
    6044           0 :         TALLOC_FREE(pull);
    6045           0 :         Py_RETURN_NONE;
    6046             : }
    6047             : 
    6048           0 : static PyObject *py_epm_InqObject_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    6049             : {
    6050           0 :         DATA_BLOB blob;
    6051           0 :         Py_ssize_t blob_length = 0;
    6052           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    6053           0 :         PyObject *bigendian_obj = NULL;
    6054           0 :         PyObject *ndr64_obj = NULL;
    6055           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    6056           0 :         PyObject *allow_remaining_obj = NULL;
    6057           0 :         bool allow_remaining = false;
    6058             : 
    6059           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
    6060             :                 discard_const_p(char *, kwnames),
    6061             :                 &blob.data, &blob_length,
    6062             :                 &bigendian_obj,
    6063             :                 &ndr64_obj,
    6064             :                 &allow_remaining_obj)) {
    6065           0 :                 return NULL;
    6066             :         }
    6067           0 :         blob.length = blob_length;
    6068             : 
    6069           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    6070           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    6071             :         }
    6072           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    6073           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    6074             :         }
    6075             : 
    6076           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    6077           0 :                 allow_remaining = true;
    6078             :         }
    6079             : 
    6080           0 :         return py_epm_InqObject_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
    6081             : }
    6082             : 
    6083           0 : static PyObject *py_epm_InqObject_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    6084             : {
    6085           0 :         DATA_BLOB blob;
    6086           0 :         Py_ssize_t blob_length = 0;
    6087           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    6088           0 :         PyObject *bigendian_obj = NULL;
    6089           0 :         PyObject *ndr64_obj = NULL;
    6090           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    6091           0 :         PyObject *allow_remaining_obj = NULL;
    6092           0 :         bool allow_remaining = false;
    6093             : 
    6094           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
    6095             :                 discard_const_p(char *, kwnames),
    6096             :                 &blob.data, &blob_length,
    6097             :                 &bigendian_obj,
    6098             :                 &ndr64_obj,
    6099             :                 &allow_remaining_obj)) {
    6100           0 :                 return NULL;
    6101             :         }
    6102           0 :         blob.length = blob_length;
    6103             : 
    6104           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    6105           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    6106             :         }
    6107           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    6108           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    6109             :         }
    6110             : 
    6111           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    6112           0 :                 allow_remaining = true;
    6113             :         }
    6114             : 
    6115           0 :         return py_epm_InqObject_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
    6116             : }
    6117             : 
    6118           0 : static PyObject *py_epm_InqObject_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
    6119             : {
    6120           0 :         const struct ndr_interface_call *call = NULL;
    6121           0 :         struct epm_InqObject *object = pytalloc_get_ptr(py_obj);
    6122           0 :         PyObject *ret;
    6123           0 :         char *retstr;
    6124             : 
    6125           0 :         if (ndr_table_epmapper.num_calls < 6) {
    6126           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_epm_InqObject_ndr_print");
    6127           0 :                 return NULL;
    6128             :         }
    6129           0 :         call = &ndr_table_epmapper.calls[5];
    6130             : 
    6131           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
    6132           0 :         ret = PyUnicode_FromString(retstr);
    6133           0 :         TALLOC_FREE(retstr);
    6134             : 
    6135           0 :         return ret;
    6136             : }
    6137             : 
    6138           0 : static PyObject *py_epm_InqObject_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    6139             : {
    6140           0 :         return py_epm_InqObject_ndr_print(py_obj, "epm_InqObject_in", NDR_IN);
    6141             : }
    6142             : 
    6143           0 : static PyObject *py_epm_InqObject_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    6144             : {
    6145           0 :         return py_epm_InqObject_ndr_print(py_obj, "epm_InqObject_out", NDR_OUT);
    6146             : }
    6147             : 
    6148             : static PyMethodDef py_epm_InqObject_methods[] = {
    6149             :         { "opnum", (PyCFunction)py_epm_InqObject_ndr_opnum, METH_NOARGS|METH_CLASS,
    6150             :                 "epmapper.epm_InqObject.opnum() -> 5 (0x05) " },
    6151             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_InqObject_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
    6152             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
    6153             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_InqObject_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
    6154             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
    6155             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_InqObject_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
    6156             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
    6157             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_InqObject_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
    6158             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
    6159             :         { "__ndr_print_in__", (PyCFunction)py_epm_InqObject_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
    6160             :         { "__ndr_print_out__", (PyCFunction)py_epm_InqObject_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
    6161             :         { NULL, NULL, 0, NULL }
    6162             : };
    6163             : 
    6164             : 
    6165             : static PyTypeObject epm_InqObject_Type = {
    6166             :         PyVarObject_HEAD_INIT(NULL, 0)
    6167             :         .tp_name = "epmapper.epm_InqObject",
    6168             :         .tp_getset = py_epm_InqObject_getsetters,
    6169             :         .tp_methods = py_epm_InqObject_methods,
    6170             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    6171             :         .tp_new = py_epm_InqObject_new,
    6172             : };
    6173             : 
    6174           0 : static bool pack_py_epm_InqObject_args_in(PyObject *args, PyObject *kwargs, struct epm_InqObject *r)
    6175             : {
    6176           0 :         PyObject *py_epm_object;
    6177           0 :         const char *kwnames[] = {
    6178             :                 "epm_object", NULL
    6179             :         };
    6180             : 
    6181           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:epm_InqObject", discard_const_p(char *, kwnames), &py_epm_object)) {
    6182           0 :                 return false;
    6183             :         }
    6184             : 
    6185           0 :         if (py_epm_object == NULL) {
    6186           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.epm_object");
    6187           0 :                 return false;
    6188             :         }
    6189           0 :         r->in.epm_object = talloc_ptrtype(r, r->in.epm_object);
    6190           0 :         if (r->in.epm_object == NULL) {
    6191           0 :                 PyErr_NoMemory();
    6192           0 :                 return false;
    6193             :         }
    6194           0 :         PY_CHECK_TYPE(GUID_Type, py_epm_object, return false;);
    6195           0 :         if (talloc_reference(r, pytalloc_get_mem_ctx(py_epm_object)) == NULL) {
    6196           0 :                 PyErr_NoMemory();
    6197           0 :                 return false;
    6198             :         }
    6199           0 :         r->in.epm_object = (struct GUID *)pytalloc_get_ptr(py_epm_object);
    6200           0 :         return true;
    6201             : }
    6202             : 
    6203           0 : static PyObject *unpack_py_epm_InqObject_args_out(struct epm_InqObject *r)
    6204             : {
    6205           0 :         PyObject *result;
    6206           0 :         result = PyLong_FromUnsignedLongLong((uint32_t)(r->out.result));
    6207           0 :         return result;
    6208             : }
    6209             : 
    6210             : 
    6211           0 : static PyObject *py_epm_MgmtDelete_in_get_object_speced(PyObject *obj, void *closure)
    6212             : {
    6213           0 :         struct epm_MgmtDelete *object = pytalloc_get_ptr(obj);
    6214           0 :         PyObject *py_object_speced;
    6215           0 :         py_object_speced = PyLong_FromUnsignedLongLong((uint32_t)(object->in.object_speced));
    6216           0 :         return py_object_speced;
    6217             : }
    6218             : 
    6219           0 : static int py_epm_MgmtDelete_in_set_object_speced(PyObject *py_obj, PyObject *value, void *closure)
    6220             : {
    6221           0 :         struct epm_MgmtDelete *object = pytalloc_get_ptr(py_obj);
    6222           0 :         if (value == NULL) {
    6223           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.object_speced");
    6224           0 :                 return -1;
    6225             :         }
    6226             :         {
    6227           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.object_speced));
    6228           0 :                 if (PyLong_Check(value)) {
    6229           0 :                         unsigned long long test_var;
    6230           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    6231           0 :                         if (PyErr_Occurred() != NULL) {
    6232           0 :                                 return -1;
    6233             :                         }
    6234           0 :                         if (test_var > uint_max) {
    6235           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    6236             :                                   PyLong_Type.tp_name, uint_max, test_var);
    6237           0 :                                 return -1;
    6238             :                         }
    6239           0 :                         object->in.object_speced = test_var;
    6240             :                 } else {
    6241           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    6242             :                           PyLong_Type.tp_name);
    6243           0 :                         return -1;
    6244             :                 }
    6245             :         }
    6246           0 :         return 0;
    6247             : }
    6248             : 
    6249           0 : static PyObject *py_epm_MgmtDelete_in_get_object(PyObject *obj, void *closure)
    6250             : {
    6251           0 :         struct epm_MgmtDelete *object = pytalloc_get_ptr(obj);
    6252           0 :         PyObject *py_object;
    6253           0 :         if (object->in.object == NULL) {
    6254           0 :                 Py_RETURN_NONE;
    6255             :         }
    6256           0 :         if (object->in.object == NULL) {
    6257           0 :                 py_object = Py_None;
    6258           0 :                 Py_INCREF(py_object);
    6259             :         } else {
    6260           0 :                 py_object = pytalloc_reference_ex(GUID_Type, object->in.object, object->in.object);
    6261             :         }
    6262           0 :         return py_object;
    6263             : }
    6264             : 
    6265           0 : static int py_epm_MgmtDelete_in_set_object(PyObject *py_obj, PyObject *value, void *closure)
    6266             : {
    6267           0 :         struct epm_MgmtDelete *object = pytalloc_get_ptr(py_obj);
    6268           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.object));
    6269           0 :         if (value == NULL) {
    6270           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.object");
    6271           0 :                 return -1;
    6272             :         }
    6273           0 :         if (value == Py_None) {
    6274           0 :                 object->in.object = NULL;
    6275             :         } else {
    6276           0 :                 object->in.object = NULL;
    6277           0 :                 PY_CHECK_TYPE(GUID_Type, value, return -1;);
    6278           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    6279           0 :                         PyErr_NoMemory();
    6280           0 :                         return -1;
    6281             :                 }
    6282           0 :                 object->in.object = (struct GUID *)pytalloc_get_ptr(value);
    6283             :         }
    6284           0 :         return 0;
    6285             : }
    6286             : 
    6287           0 : static PyObject *py_epm_MgmtDelete_in_get_tower(PyObject *obj, void *closure)
    6288             : {
    6289           0 :         struct epm_MgmtDelete *object = pytalloc_get_ptr(obj);
    6290           0 :         PyObject *py_tower;
    6291           0 :         if (object->in.tower == NULL) {
    6292           0 :                 Py_RETURN_NONE;
    6293             :         }
    6294           0 :         if (object->in.tower == NULL) {
    6295           0 :                 py_tower = Py_None;
    6296           0 :                 Py_INCREF(py_tower);
    6297             :         } else {
    6298           0 :                 py_tower = pytalloc_reference_ex(&epm_twr_t_Type, object->in.tower, object->in.tower);
    6299             :         }
    6300           0 :         return py_tower;
    6301             : }
    6302             : 
    6303           0 : static int py_epm_MgmtDelete_in_set_tower(PyObject *py_obj, PyObject *value, void *closure)
    6304             : {
    6305           0 :         struct epm_MgmtDelete *object = pytalloc_get_ptr(py_obj);
    6306           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.tower));
    6307           0 :         if (value == NULL) {
    6308           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.tower");
    6309           0 :                 return -1;
    6310             :         }
    6311           0 :         if (value == Py_None) {
    6312           0 :                 object->in.tower = NULL;
    6313             :         } else {
    6314           0 :                 object->in.tower = NULL;
    6315           0 :                 PY_CHECK_TYPE(&epm_twr_t_Type, value, return -1;);
    6316           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    6317           0 :                         PyErr_NoMemory();
    6318           0 :                         return -1;
    6319             :                 }
    6320           0 :                 object->in.tower = (struct epm_twr_t *)pytalloc_get_ptr(value);
    6321             :         }
    6322           0 :         return 0;
    6323             : }
    6324             : 
    6325           0 : static PyObject *py_epm_MgmtDelete_get_result(PyObject *obj, void *closure)
    6326             : {
    6327           0 :         struct epm_MgmtDelete *object = pytalloc_get_ptr(obj);
    6328           0 :         PyObject *py_result;
    6329           0 :         py_result = PyLong_FromUnsignedLongLong((uint32_t)(object->out.result));
    6330           0 :         return py_result;
    6331             : }
    6332             : 
    6333           0 : static int py_epm_MgmtDelete_set_result(PyObject *py_obj, PyObject *value, void *closure)
    6334             : {
    6335           0 :         struct epm_MgmtDelete *object = pytalloc_get_ptr(py_obj);
    6336           0 :         if (value == NULL) {
    6337           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.result");
    6338           0 :                 return -1;
    6339             :         }
    6340             :         {
    6341           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->out.result));
    6342           0 :                 if (PyLong_Check(value)) {
    6343           0 :                         unsigned long long test_var;
    6344           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    6345           0 :                         if (PyErr_Occurred() != NULL) {
    6346           0 :                                 return -1;
    6347             :                         }
    6348           0 :                         if (test_var > uint_max) {
    6349           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    6350             :                                   PyLong_Type.tp_name, uint_max, test_var);
    6351           0 :                                 return -1;
    6352             :                         }
    6353           0 :                         object->out.result = test_var;
    6354             :                 } else {
    6355           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    6356             :                           PyLong_Type.tp_name);
    6357           0 :                         return -1;
    6358             :                 }
    6359             :         }
    6360           0 :         return 0;
    6361             : }
    6362             : 
    6363             : static PyGetSetDef py_epm_MgmtDelete_getsetters[] = {
    6364             :         {
    6365             :                 .name = discard_const_p(char, "in_object_speced"),
    6366             :                 .get = py_epm_MgmtDelete_in_get_object_speced,
    6367             :                 .set = py_epm_MgmtDelete_in_set_object_speced,
    6368             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    6369             :         },
    6370             :         {
    6371             :                 .name = discard_const_p(char, "in_object"),
    6372             :                 .get = py_epm_MgmtDelete_in_get_object,
    6373             :                 .set = py_epm_MgmtDelete_in_set_object,
    6374             :                 .doc = discard_const_p(char, "PIDL-generated element of base type GUID")
    6375             :         },
    6376             :         {
    6377             :                 .name = discard_const_p(char, "in_tower"),
    6378             :                 .get = py_epm_MgmtDelete_in_get_tower,
    6379             :                 .set = py_epm_MgmtDelete_in_set_tower,
    6380             :                 .doc = discard_const_p(char, "PIDL-generated element of base type epm_twr_t")
    6381             :         },
    6382             :         {
    6383             :                 .name = discard_const_p(char, "result"),
    6384             :                 .get = py_epm_MgmtDelete_get_result,
    6385             :                 .set = py_epm_MgmtDelete_set_result,
    6386             :                 .doc = discard_const_p(char, "PIDL-generated element of type uint32")
    6387             :         },
    6388             :         { .name = NULL }
    6389             : };
    6390             : 
    6391           0 : static PyObject *py_epm_MgmtDelete_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    6392             : {
    6393           0 :         PyObject *self = pytalloc_new(struct epm_MgmtDelete, type);
    6394           0 :         return self;
    6395             : }
    6396             : 
    6397           0 : static PyObject *py_epm_MgmtDelete_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
    6398             : {
    6399             : 
    6400             : 
    6401           0 :         return PyLong_FromLong(6);
    6402             : }
    6403             : 
    6404           0 : static PyObject *py_epm_MgmtDelete_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
    6405             : {
    6406           0 :         const struct ndr_interface_call *call = NULL;
    6407           0 :         struct epm_MgmtDelete *object = pytalloc_get_ptr(py_obj);
    6408           0 :         PyObject *ret = NULL;
    6409           0 :         struct ndr_push *push = NULL;
    6410           0 :         DATA_BLOB blob;
    6411           0 :         enum ndr_err_code err;
    6412             : 
    6413           0 :         if (ndr_table_epmapper.num_calls < 7) {
    6414           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_epm_MgmtDelete_ndr_pack");
    6415           0 :                 return NULL;
    6416             :         }
    6417           0 :         call = &ndr_table_epmapper.calls[6];
    6418             : 
    6419           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
    6420           0 :         if (push == NULL) {
    6421           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    6422           0 :                 return NULL;
    6423             :         }
    6424             : 
    6425           0 :         push->flags |= ndr_push_flags;
    6426             : 
    6427           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
    6428           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    6429           0 :                 TALLOC_FREE(push);
    6430           0 :                 PyErr_SetNdrError(err);
    6431           0 :                 return NULL;
    6432             :         }
    6433           0 :         blob = ndr_push_blob(push);
    6434           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
    6435           0 :         TALLOC_FREE(push);
    6436           0 :         return ret;
    6437             : }
    6438             : 
    6439           0 : static PyObject *py_epm_MgmtDelete_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    6440             : {
    6441           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    6442           0 :         PyObject *bigendian_obj = NULL;
    6443           0 :         PyObject *ndr64_obj = NULL;
    6444           0 :         libndr_flags ndr_push_flags = 0;
    6445             : 
    6446           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
    6447             :                 discard_const_p(char *, kwnames),
    6448             :                 &bigendian_obj,
    6449             :                 &ndr64_obj)) {
    6450           0 :                 return NULL;
    6451             :         }
    6452             : 
    6453           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    6454           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    6455             :         }
    6456           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    6457           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    6458             :         }
    6459             : 
    6460           0 :         return py_epm_MgmtDelete_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
    6461             : }
    6462             : 
    6463           0 : static PyObject *py_epm_MgmtDelete_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    6464             : {
    6465           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    6466           0 :         PyObject *bigendian_obj = NULL;
    6467           0 :         PyObject *ndr64_obj = NULL;
    6468           0 :         libndr_flags ndr_push_flags = 0;
    6469             : 
    6470           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
    6471             :                 discard_const_p(char *, kwnames),
    6472             :                 &bigendian_obj,
    6473             :                 &ndr64_obj)) {
    6474           0 :                 return NULL;
    6475             :         }
    6476             : 
    6477           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    6478           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    6479             :         }
    6480           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    6481           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    6482             :         }
    6483             : 
    6484           0 :         return py_epm_MgmtDelete_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
    6485             : }
    6486             : 
    6487           0 : static PyObject *py_epm_MgmtDelete_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
    6488             : {
    6489           0 :         const struct ndr_interface_call *call = NULL;
    6490           0 :         struct epm_MgmtDelete *object = pytalloc_get_ptr(py_obj);
    6491           0 :         struct ndr_pull *pull = NULL;
    6492           0 :         enum ndr_err_code err;
    6493             : 
    6494           0 :         if (ndr_table_epmapper.num_calls < 7) {
    6495           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_epm_MgmtDelete_ndr_unpack");
    6496           0 :                 return NULL;
    6497             :         }
    6498           0 :         call = &ndr_table_epmapper.calls[6];
    6499             : 
    6500           0 :         pull = ndr_pull_init_blob(blob, object);
    6501           0 :         if (pull == NULL) {
    6502           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    6503           0 :                 return NULL;
    6504             :         }
    6505             : 
    6506           0 :         pull->flags |= ndr_pull_flags;
    6507             : 
    6508           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
    6509           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    6510           0 :                 TALLOC_FREE(pull);
    6511           0 :                 PyErr_SetNdrError(err);
    6512           0 :                 return NULL;
    6513             :         }
    6514           0 :         if (!allow_remaining) {
    6515           0 :                 uint32_t highest_ofs;
    6516             : 
    6517           0 :                 if (pull->offset > pull->relative_highest_offset) {
    6518           0 :                         highest_ofs = pull->offset;
    6519             :                 } else {
    6520           0 :                         highest_ofs = pull->relative_highest_offset;
    6521             :                 }
    6522           0 :                 if (highest_ofs < pull->data_size) {
    6523           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
    6524             :                                 "not all bytes consumed ofs[%u] size[%u]",
    6525             :                                 highest_ofs, pull->data_size);
    6526           0 :                         TALLOC_FREE(pull);
    6527           0 :                         PyErr_SetNdrError(err);
    6528           0 :                         return NULL;
    6529             :                 }
    6530             :         }
    6531             : 
    6532           0 :         TALLOC_FREE(pull);
    6533           0 :         Py_RETURN_NONE;
    6534             : }
    6535             : 
    6536           0 : static PyObject *py_epm_MgmtDelete_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    6537             : {
    6538           0 :         DATA_BLOB blob;
    6539           0 :         Py_ssize_t blob_length = 0;
    6540           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    6541           0 :         PyObject *bigendian_obj = NULL;
    6542           0 :         PyObject *ndr64_obj = NULL;
    6543           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    6544           0 :         PyObject *allow_remaining_obj = NULL;
    6545           0 :         bool allow_remaining = false;
    6546             : 
    6547           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
    6548             :                 discard_const_p(char *, kwnames),
    6549             :                 &blob.data, &blob_length,
    6550             :                 &bigendian_obj,
    6551             :                 &ndr64_obj,
    6552             :                 &allow_remaining_obj)) {
    6553           0 :                 return NULL;
    6554             :         }
    6555           0 :         blob.length = blob_length;
    6556             : 
    6557           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    6558           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    6559             :         }
    6560           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    6561           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    6562             :         }
    6563             : 
    6564           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    6565           0 :                 allow_remaining = true;
    6566             :         }
    6567             : 
    6568           0 :         return py_epm_MgmtDelete_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
    6569             : }
    6570             : 
    6571           0 : static PyObject *py_epm_MgmtDelete_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    6572             : {
    6573           0 :         DATA_BLOB blob;
    6574           0 :         Py_ssize_t blob_length = 0;
    6575           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    6576           0 :         PyObject *bigendian_obj = NULL;
    6577           0 :         PyObject *ndr64_obj = NULL;
    6578           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    6579           0 :         PyObject *allow_remaining_obj = NULL;
    6580           0 :         bool allow_remaining = false;
    6581             : 
    6582           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
    6583             :                 discard_const_p(char *, kwnames),
    6584             :                 &blob.data, &blob_length,
    6585             :                 &bigendian_obj,
    6586             :                 &ndr64_obj,
    6587             :                 &allow_remaining_obj)) {
    6588           0 :                 return NULL;
    6589             :         }
    6590           0 :         blob.length = blob_length;
    6591             : 
    6592           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    6593           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    6594             :         }
    6595           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    6596           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    6597             :         }
    6598             : 
    6599           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    6600           0 :                 allow_remaining = true;
    6601             :         }
    6602             : 
    6603           0 :         return py_epm_MgmtDelete_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
    6604             : }
    6605             : 
    6606           0 : static PyObject *py_epm_MgmtDelete_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
    6607             : {
    6608           0 :         const struct ndr_interface_call *call = NULL;
    6609           0 :         struct epm_MgmtDelete *object = pytalloc_get_ptr(py_obj);
    6610           0 :         PyObject *ret;
    6611           0 :         char *retstr;
    6612             : 
    6613           0 :         if (ndr_table_epmapper.num_calls < 7) {
    6614           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_epm_MgmtDelete_ndr_print");
    6615           0 :                 return NULL;
    6616             :         }
    6617           0 :         call = &ndr_table_epmapper.calls[6];
    6618             : 
    6619           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
    6620           0 :         ret = PyUnicode_FromString(retstr);
    6621           0 :         TALLOC_FREE(retstr);
    6622             : 
    6623           0 :         return ret;
    6624             : }
    6625             : 
    6626           0 : static PyObject *py_epm_MgmtDelete_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    6627             : {
    6628           0 :         return py_epm_MgmtDelete_ndr_print(py_obj, "epm_MgmtDelete_in", NDR_IN);
    6629             : }
    6630             : 
    6631           0 : static PyObject *py_epm_MgmtDelete_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    6632             : {
    6633           0 :         return py_epm_MgmtDelete_ndr_print(py_obj, "epm_MgmtDelete_out", NDR_OUT);
    6634             : }
    6635             : 
    6636             : static PyMethodDef py_epm_MgmtDelete_methods[] = {
    6637             :         { "opnum", (PyCFunction)py_epm_MgmtDelete_ndr_opnum, METH_NOARGS|METH_CLASS,
    6638             :                 "epmapper.epm_MgmtDelete.opnum() -> 6 (0x06) " },
    6639             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_MgmtDelete_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
    6640             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
    6641             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_MgmtDelete_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
    6642             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
    6643             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_MgmtDelete_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
    6644             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
    6645             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_epm_MgmtDelete_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
    6646             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
    6647             :         { "__ndr_print_in__", (PyCFunction)py_epm_MgmtDelete_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
    6648             :         { "__ndr_print_out__", (PyCFunction)py_epm_MgmtDelete_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
    6649             :         { NULL, NULL, 0, NULL }
    6650             : };
    6651             : 
    6652             : 
    6653             : static PyTypeObject epm_MgmtDelete_Type = {
    6654             :         PyVarObject_HEAD_INIT(NULL, 0)
    6655             :         .tp_name = "epmapper.epm_MgmtDelete",
    6656             :         .tp_getset = py_epm_MgmtDelete_getsetters,
    6657             :         .tp_methods = py_epm_MgmtDelete_methods,
    6658             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    6659             :         .tp_new = py_epm_MgmtDelete_new,
    6660             : };
    6661             : 
    6662           0 : static bool pack_py_epm_MgmtDelete_args_in(PyObject *args, PyObject *kwargs, struct epm_MgmtDelete *r)
    6663             : {
    6664           0 :         PyObject *py_object_speced;
    6665           0 :         PyObject *py_object;
    6666           0 :         PyObject *py_tower;
    6667           0 :         const char *kwnames[] = {
    6668             :                 "object_speced", "object", "tower", NULL
    6669             :         };
    6670             : 
    6671           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:epm_MgmtDelete", discard_const_p(char *, kwnames), &py_object_speced, &py_object, &py_tower)) {
    6672           0 :                 return false;
    6673             :         }
    6674             : 
    6675           0 :         if (py_object_speced == NULL) {
    6676           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.object_speced");
    6677           0 :                 return false;
    6678             :         }
    6679             :         {
    6680           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.object_speced));
    6681           0 :                 if (PyLong_Check(py_object_speced)) {
    6682           0 :                         unsigned long long test_var;
    6683           0 :                         test_var = PyLong_AsUnsignedLongLong(py_object_speced);
    6684           0 :                         if (PyErr_Occurred() != NULL) {
    6685           0 :                                 return false;
    6686             :                         }
    6687           0 :                         if (test_var > uint_max) {
    6688           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    6689             :                                   PyLong_Type.tp_name, uint_max, test_var);
    6690           0 :                                 return false;
    6691             :                         }
    6692           0 :                         r->in.object_speced = test_var;
    6693             :                 } else {
    6694           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    6695             :                           PyLong_Type.tp_name);
    6696           0 :                         return false;
    6697             :                 }
    6698             :         }
    6699           0 :         if (py_object == NULL) {
    6700           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.object");
    6701           0 :                 return false;
    6702             :         }
    6703           0 :         if (py_object == Py_None) {
    6704           0 :                 r->in.object = NULL;
    6705             :         } else {
    6706           0 :                 r->in.object = NULL;
    6707           0 :                 PY_CHECK_TYPE(GUID_Type, py_object, return false;);
    6708           0 :                 if (talloc_reference(r, pytalloc_get_mem_ctx(py_object)) == NULL) {
    6709           0 :                         PyErr_NoMemory();
    6710           0 :                         return false;
    6711             :                 }
    6712           0 :                 r->in.object = (struct GUID *)pytalloc_get_ptr(py_object);
    6713             :         }
    6714           0 :         if (py_tower == NULL) {
    6715           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.tower");
    6716           0 :                 return false;
    6717             :         }
    6718           0 :         if (py_tower == Py_None) {
    6719           0 :                 r->in.tower = NULL;
    6720             :         } else {
    6721           0 :                 r->in.tower = NULL;
    6722           0 :                 PY_CHECK_TYPE(&epm_twr_t_Type, py_tower, return false;);
    6723           0 :                 if (talloc_reference(r, pytalloc_get_mem_ctx(py_tower)) == NULL) {
    6724           0 :                         PyErr_NoMemory();
    6725           0 :                         return false;
    6726             :                 }
    6727           0 :                 r->in.tower = (struct epm_twr_t *)pytalloc_get_ptr(py_tower);
    6728             :         }
    6729           0 :         return true;
    6730             : }
    6731             : 
    6732           0 : static PyObject *unpack_py_epm_MgmtDelete_args_out(struct epm_MgmtDelete *r)
    6733             : {
    6734           0 :         PyObject *result;
    6735           0 :         result = PyLong_FromUnsignedLongLong((uint32_t)(r->out.result));
    6736           0 :         return result;
    6737             : }
    6738             : 
    6739             : const struct PyNdrRpcMethodDef py_ndr_epmapper_methods[] = {
    6740             :         { "epm_Insert", "S.epm_Insert(entries, replace) -> result", (py_dcerpc_call_fn)dcerpc_epm_Insert_r, (py_data_pack_fn)pack_py_epm_Insert_args_in, (py_data_unpack_fn)unpack_py_epm_Insert_args_out, 0, &ndr_table_epmapper },
    6741             :         { "epm_Delete", "S.epm_Delete(entries) -> result", (py_dcerpc_call_fn)dcerpc_epm_Delete_r, (py_data_pack_fn)pack_py_epm_Delete_args_in, (py_data_unpack_fn)unpack_py_epm_Delete_args_out, 1, &ndr_table_epmapper },
    6742             :         { "epm_Lookup", "S.epm_Lookup(inquiry_type, object, interface_id, vers_option, entry_handle, max_ents) -> (entry_handle, entries, result)", (py_dcerpc_call_fn)dcerpc_epm_Lookup_r, (py_data_pack_fn)pack_py_epm_Lookup_args_in, (py_data_unpack_fn)unpack_py_epm_Lookup_args_out, 2, &ndr_table_epmapper },
    6743             :         { "epm_Map", "S.epm_Map(object, map_tower, entry_handle, max_towers) -> (entry_handle, towers, result)", (py_dcerpc_call_fn)dcerpc_epm_Map_r, (py_data_pack_fn)pack_py_epm_Map_args_in, (py_data_unpack_fn)unpack_py_epm_Map_args_out, 3, &ndr_table_epmapper },
    6744             :         { "epm_LookupHandleFree", "S.epm_LookupHandleFree(entry_handle) -> (entry_handle, result)", (py_dcerpc_call_fn)dcerpc_epm_LookupHandleFree_r, (py_data_pack_fn)pack_py_epm_LookupHandleFree_args_in, (py_data_unpack_fn)unpack_py_epm_LookupHandleFree_args_out, 4, &ndr_table_epmapper },
    6745             :         { "epm_InqObject", "S.epm_InqObject(epm_object) -> result", (py_dcerpc_call_fn)dcerpc_epm_InqObject_r, (py_data_pack_fn)pack_py_epm_InqObject_args_in, (py_data_unpack_fn)unpack_py_epm_InqObject_args_out, 5, &ndr_table_epmapper },
    6746             :         { "epm_MgmtDelete", "S.epm_MgmtDelete(object_speced, object, tower) -> result", (py_dcerpc_call_fn)dcerpc_epm_MgmtDelete_r, (py_data_pack_fn)pack_py_epm_MgmtDelete_args_in, (py_data_unpack_fn)unpack_py_epm_MgmtDelete_args_out, 6, &ndr_table_epmapper },
    6747             :         {0}
    6748             : };
    6749             : 
    6750           0 : static PyObject *interface_epmapper_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    6751             : {
    6752           0 :         return py_dcerpc_interface_init_helper(type, args, kwargs, &ndr_table_epmapper);
    6753             : }
    6754             : 
    6755             : #define PY_DOC_EPMAPPER "EndPoint Mapper"
    6756             : static PyTypeObject epmapper_InterfaceType = {
    6757             :         PyVarObject_HEAD_INIT(NULL, 0)
    6758             :         .tp_name = "epmapper.epmapper",
    6759             :         .tp_basicsize = sizeof(dcerpc_InterfaceObject),
    6760             :         .tp_doc = "epmapper(binding, lp_ctx=None, credentials=None) -> connection\n"
    6761             : "\n"
    6762             : "binding should be a DCE/RPC binding string (for example: ncacn_ip_tcp:127.0.0.1)\n"
    6763             : "lp_ctx should be a path to a smb.conf file or a param.LoadParm object\n"
    6764             : "credentials should be a credentials.Credentials object.\n\n"PY_DOC_EPMAPPER,
    6765             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    6766             :         .tp_new = interface_epmapper_new,
    6767             : };
    6768             : 
    6769          57 : static PyObject *syntax_epmapper_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    6770             : {
    6771          57 :         return py_dcerpc_syntax_init_helper(type, args, kwargs, &ndr_table_epmapper.syntax_id);
    6772             : }
    6773             : 
    6774             : #define PY_DOC_EPMAPPER_SYNTAX "EndPoint Mapper"
    6775             : static PyTypeObject epmapper_SyntaxType = {
    6776             :         PyVarObject_HEAD_INIT(NULL, 0)
    6777             :         .tp_name = "epmapper.epmapper_abstract_syntax",
    6778             :         .tp_doc = "epmapper_abstract_syntax()\n"PY_DOC_EPMAPPER_SYNTAX,
    6779             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    6780             :         .tp_new = syntax_epmapper_new,
    6781             : };
    6782             : 
    6783             : static PyMethodDef epmapper_methods[] = {
    6784             :         { NULL, NULL, 0, NULL }
    6785             : };
    6786             : 
    6787             : static struct PyModuleDef moduledef = {
    6788             :         PyModuleDef_HEAD_INIT,
    6789             :         .m_name = "epmapper",
    6790             :         .m_doc = "epmapper DCE/RPC",
    6791             :         .m_size = -1,
    6792             :         .m_methods = epmapper_methods,
    6793             : };
    6794         698 : MODULE_INIT_FUNC(epmapper)
    6795             : {
    6796         698 :         PyObject *m = NULL;
    6797         698 :         PyObject *dep_samba_dcerpc_misc = NULL;
    6798         698 :         PyObject *dep_talloc = NULL;
    6799         698 :         PyObject *dep_samba_dcerpc_base = NULL;
    6800             : 
    6801         698 :         dep_samba_dcerpc_misc = PyImport_ImportModule("samba.dcerpc.misc");
    6802         698 :         if (dep_samba_dcerpc_misc == NULL)
    6803           0 :                 goto out;
    6804             : 
    6805         698 :         dep_talloc = PyImport_ImportModule("talloc");
    6806         698 :         if (dep_talloc == NULL)
    6807           0 :                 goto out;
    6808             : 
    6809         698 :         dep_samba_dcerpc_base = PyImport_ImportModule("samba.dcerpc.base");
    6810         698 :         if (dep_samba_dcerpc_base == NULL)
    6811           0 :                 goto out;
    6812             : 
    6813         698 :         BaseObject_Type = (PyTypeObject *)PyObject_GetAttrString(dep_talloc, "BaseObject");
    6814         698 :         if (BaseObject_Type == NULL)
    6815           0 :                 goto out;
    6816             : 
    6817         698 :         GUID_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_misc, "GUID");
    6818         698 :         if (GUID_Type == NULL)
    6819           0 :                 goto out;
    6820             : 
    6821         698 :         policy_handle_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_misc, "policy_handle");
    6822         698 :         if (policy_handle_Type == NULL)
    6823           0 :                 goto out;
    6824             : 
    6825         698 :         ClientConnection_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_base, "ClientConnection");
    6826         698 :         if (ClientConnection_Type == NULL)
    6827           0 :                 goto out;
    6828             : 
    6829         698 :         ndr_syntax_id_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_misc, "ndr_syntax_id");
    6830         698 :         if (ndr_syntax_id_Type == NULL)
    6831           0 :                 goto out;
    6832             : 
    6833         698 :         epm_rhs_dnet_nsp_Type.tp_base = BaseObject_Type;
    6834         698 :         epm_rhs_dnet_nsp_Type.tp_basicsize = pytalloc_BaseObject_size();
    6835             : 
    6836         698 :         epm_rhs_osi_tp4_Type.tp_base = BaseObject_Type;
    6837         698 :         epm_rhs_osi_tp4_Type.tp_basicsize = pytalloc_BaseObject_size();
    6838             : 
    6839         698 :         epm_rhs_osi_clns_Type.tp_base = BaseObject_Type;
    6840         698 :         epm_rhs_osi_clns_Type.tp_basicsize = pytalloc_BaseObject_size();
    6841             : 
    6842         698 :         epm_rhs_udp_Type.tp_base = BaseObject_Type;
    6843         698 :         epm_rhs_udp_Type.tp_basicsize = pytalloc_BaseObject_size();
    6844             : 
    6845         698 :         epm_rhs_tcp_Type.tp_base = BaseObject_Type;
    6846         698 :         epm_rhs_tcp_Type.tp_basicsize = pytalloc_BaseObject_size();
    6847             : 
    6848         698 :         epm_rhs_ip_Type.tp_base = BaseObject_Type;
    6849         698 :         epm_rhs_ip_Type.tp_basicsize = pytalloc_BaseObject_size();
    6850             : 
    6851         698 :         epm_rhs_ncadg_Type.tp_base = BaseObject_Type;
    6852         698 :         epm_rhs_ncadg_Type.tp_basicsize = pytalloc_BaseObject_size();
    6853             : 
    6854         698 :         epm_rhs_ncacn_Type.tp_base = BaseObject_Type;
    6855         698 :         epm_rhs_ncacn_Type.tp_basicsize = pytalloc_BaseObject_size();
    6856             : 
    6857         698 :         epm_rhs_uuid_Type.tp_base = BaseObject_Type;
    6858         698 :         epm_rhs_uuid_Type.tp_basicsize = pytalloc_BaseObject_size();
    6859             : 
    6860         698 :         epm_rhs_ipx_Type.tp_base = BaseObject_Type;
    6861         698 :         epm_rhs_ipx_Type.tp_basicsize = pytalloc_BaseObject_size();
    6862             : 
    6863         698 :         epm_rhs_smb_Type.tp_base = BaseObject_Type;
    6864         698 :         epm_rhs_smb_Type.tp_basicsize = pytalloc_BaseObject_size();
    6865             : 
    6866         698 :         epm_rhs_named_pipe_Type.tp_base = BaseObject_Type;
    6867         698 :         epm_rhs_named_pipe_Type.tp_basicsize = pytalloc_BaseObject_size();
    6868             : 
    6869         698 :         epm_rhs_netbios_Type.tp_base = BaseObject_Type;
    6870         698 :         epm_rhs_netbios_Type.tp_basicsize = pytalloc_BaseObject_size();
    6871             : 
    6872         698 :         epm_rhs_netbeui_Type.tp_base = BaseObject_Type;
    6873         698 :         epm_rhs_netbeui_Type.tp_basicsize = pytalloc_BaseObject_size();
    6874             : 
    6875         698 :         epm_rhs_spx_Type.tp_base = BaseObject_Type;
    6876         698 :         epm_rhs_spx_Type.tp_basicsize = pytalloc_BaseObject_size();
    6877             : 
    6878         698 :         epm_rhs_nb_ipx_Type.tp_base = BaseObject_Type;
    6879         698 :         epm_rhs_nb_ipx_Type.tp_basicsize = pytalloc_BaseObject_size();
    6880             : 
    6881         698 :         epm_rhs_http_Type.tp_base = BaseObject_Type;
    6882         698 :         epm_rhs_http_Type.tp_basicsize = pytalloc_BaseObject_size();
    6883             : 
    6884         698 :         epm_rhs_unix_ds_Type.tp_base = BaseObject_Type;
    6885         698 :         epm_rhs_unix_ds_Type.tp_basicsize = pytalloc_BaseObject_size();
    6886             : 
    6887         698 :         epm_rhs_null_Type.tp_base = BaseObject_Type;
    6888         698 :         epm_rhs_null_Type.tp_basicsize = pytalloc_BaseObject_size();
    6889             : 
    6890         698 :         epm_rhs_ncalrpc_Type.tp_base = BaseObject_Type;
    6891         698 :         epm_rhs_ncalrpc_Type.tp_basicsize = pytalloc_BaseObject_size();
    6892             : 
    6893         698 :         epm_rhs_appletalk_Type.tp_base = BaseObject_Type;
    6894         698 :         epm_rhs_appletalk_Type.tp_basicsize = pytalloc_BaseObject_size();
    6895             : 
    6896         698 :         epm_rhs_atalk_stream_Type.tp_base = BaseObject_Type;
    6897         698 :         epm_rhs_atalk_stream_Type.tp_basicsize = pytalloc_BaseObject_size();
    6898             : 
    6899         698 :         epm_rhs_atalk_datagram_Type.tp_base = BaseObject_Type;
    6900         698 :         epm_rhs_atalk_datagram_Type.tp_basicsize = pytalloc_BaseObject_size();
    6901             : 
    6902         698 :         epm_rhs_vines_spp_Type.tp_base = BaseObject_Type;
    6903         698 :         epm_rhs_vines_spp_Type.tp_basicsize = pytalloc_BaseObject_size();
    6904             : 
    6905         698 :         epm_rhs_vines_ipc_Type.tp_base = BaseObject_Type;
    6906         698 :         epm_rhs_vines_ipc_Type.tp_basicsize = pytalloc_BaseObject_size();
    6907             : 
    6908         698 :         epm_rhs_streettalk_Type.tp_base = BaseObject_Type;
    6909         698 :         epm_rhs_streettalk_Type.tp_basicsize = pytalloc_BaseObject_size();
    6910             : 
    6911         698 :         epm_rhs_Type.tp_base = BaseObject_Type;
    6912         698 :         epm_rhs_Type.tp_basicsize = pytalloc_BaseObject_size();
    6913             : 
    6914         698 :         epm_lhs_Type.tp_base = BaseObject_Type;
    6915         698 :         epm_lhs_Type.tp_basicsize = pytalloc_BaseObject_size();
    6916             : 
    6917         698 :         epm_floor_Type.tp_base = BaseObject_Type;
    6918         698 :         epm_floor_Type.tp_basicsize = pytalloc_BaseObject_size();
    6919             : 
    6920         698 :         epm_tower_Type.tp_base = BaseObject_Type;
    6921         698 :         epm_tower_Type.tp_basicsize = pytalloc_BaseObject_size();
    6922             : 
    6923         698 :         epm_twr_t_Type.tp_base = BaseObject_Type;
    6924         698 :         epm_twr_t_Type.tp_basicsize = pytalloc_BaseObject_size();
    6925             : 
    6926         698 :         epm_entry_t_Type.tp_base = BaseObject_Type;
    6927         698 :         epm_entry_t_Type.tp_basicsize = pytalloc_BaseObject_size();
    6928             : 
    6929         698 :         rpc_if_id_t_Type.tp_base = BaseObject_Type;
    6930         698 :         rpc_if_id_t_Type.tp_basicsize = pytalloc_BaseObject_size();
    6931             : 
    6932         698 :         epm_twr_p_t_Type.tp_base = BaseObject_Type;
    6933         698 :         epm_twr_p_t_Type.tp_basicsize = pytalloc_BaseObject_size();
    6934             : 
    6935         698 :         epm_Insert_Type.tp_base = BaseObject_Type;
    6936         698 :         epm_Insert_Type.tp_basicsize = pytalloc_BaseObject_size();
    6937             : 
    6938         698 :         epm_Delete_Type.tp_base = BaseObject_Type;
    6939         698 :         epm_Delete_Type.tp_basicsize = pytalloc_BaseObject_size();
    6940             : 
    6941         698 :         epm_Lookup_Type.tp_base = BaseObject_Type;
    6942         698 :         epm_Lookup_Type.tp_basicsize = pytalloc_BaseObject_size();
    6943             : 
    6944         698 :         epm_Map_Type.tp_base = BaseObject_Type;
    6945         698 :         epm_Map_Type.tp_basicsize = pytalloc_BaseObject_size();
    6946             : 
    6947         698 :         epm_LookupHandleFree_Type.tp_base = BaseObject_Type;
    6948         698 :         epm_LookupHandleFree_Type.tp_basicsize = pytalloc_BaseObject_size();
    6949             : 
    6950         698 :         epm_InqObject_Type.tp_base = BaseObject_Type;
    6951         698 :         epm_InqObject_Type.tp_basicsize = pytalloc_BaseObject_size();
    6952             : 
    6953         698 :         epm_MgmtDelete_Type.tp_base = BaseObject_Type;
    6954         698 :         epm_MgmtDelete_Type.tp_basicsize = pytalloc_BaseObject_size();
    6955             : 
    6956         698 :         epmapper_InterfaceType.tp_base = ClientConnection_Type;
    6957             : 
    6958         698 :         epmapper_SyntaxType.tp_base = ndr_syntax_id_Type;
    6959         698 :         epmapper_SyntaxType.tp_basicsize = pytalloc_BaseObject_size();
    6960             : 
    6961         698 :         if (PyType_Ready(&epm_rhs_dnet_nsp_Type) < 0)
    6962           0 :                 goto out;
    6963         698 :         if (PyType_Ready(&epm_rhs_osi_tp4_Type) < 0)
    6964           0 :                 goto out;
    6965         698 :         if (PyType_Ready(&epm_rhs_osi_clns_Type) < 0)
    6966           0 :                 goto out;
    6967         698 :         if (PyType_Ready(&epm_rhs_udp_Type) < 0)
    6968           0 :                 goto out;
    6969         698 :         if (PyType_Ready(&epm_rhs_tcp_Type) < 0)
    6970           0 :                 goto out;
    6971         698 :         if (PyType_Ready(&epm_rhs_ip_Type) < 0)
    6972           0 :                 goto out;
    6973         698 :         if (PyType_Ready(&epm_rhs_ncadg_Type) < 0)
    6974           0 :                 goto out;
    6975         698 :         if (PyType_Ready(&epm_rhs_ncacn_Type) < 0)
    6976           0 :                 goto out;
    6977         698 :         if (PyType_Ready(&epm_rhs_uuid_Type) < 0)
    6978           0 :                 goto out;
    6979         698 :         if (PyType_Ready(&epm_rhs_ipx_Type) < 0)
    6980           0 :                 goto out;
    6981         698 :         if (PyType_Ready(&epm_rhs_smb_Type) < 0)
    6982           0 :                 goto out;
    6983         698 :         if (PyType_Ready(&epm_rhs_named_pipe_Type) < 0)
    6984           0 :                 goto out;
    6985         698 :         if (PyType_Ready(&epm_rhs_netbios_Type) < 0)
    6986           0 :                 goto out;
    6987         698 :         if (PyType_Ready(&epm_rhs_netbeui_Type) < 0)
    6988           0 :                 goto out;
    6989         698 :         if (PyType_Ready(&epm_rhs_spx_Type) < 0)
    6990           0 :                 goto out;
    6991         698 :         if (PyType_Ready(&epm_rhs_nb_ipx_Type) < 0)
    6992           0 :                 goto out;
    6993         698 :         if (PyType_Ready(&epm_rhs_http_Type) < 0)
    6994           0 :                 goto out;
    6995         698 :         if (PyType_Ready(&epm_rhs_unix_ds_Type) < 0)
    6996           0 :                 goto out;
    6997         698 :         if (PyType_Ready(&epm_rhs_null_Type) < 0)
    6998           0 :                 goto out;
    6999         698 :         if (PyType_Ready(&epm_rhs_ncalrpc_Type) < 0)
    7000           0 :                 goto out;
    7001         698 :         if (PyType_Ready(&epm_rhs_appletalk_Type) < 0)
    7002           0 :                 goto out;
    7003         698 :         if (PyType_Ready(&epm_rhs_atalk_stream_Type) < 0)
    7004           0 :                 goto out;
    7005         698 :         if (PyType_Ready(&epm_rhs_atalk_datagram_Type) < 0)
    7006           0 :                 goto out;
    7007         698 :         if (PyType_Ready(&epm_rhs_vines_spp_Type) < 0)
    7008           0 :                 goto out;
    7009         698 :         if (PyType_Ready(&epm_rhs_vines_ipc_Type) < 0)
    7010           0 :                 goto out;
    7011         698 :         if (PyType_Ready(&epm_rhs_streettalk_Type) < 0)
    7012           0 :                 goto out;
    7013         698 :         if (PyType_Ready(&epm_rhs_Type) < 0)
    7014           0 :                 goto out;
    7015         698 :         if (PyType_Ready(&epm_lhs_Type) < 0)
    7016           0 :                 goto out;
    7017         698 :         if (PyType_Ready(&epm_floor_Type) < 0)
    7018           0 :                 goto out;
    7019         698 :         if (PyType_Ready(&epm_tower_Type) < 0)
    7020           0 :                 goto out;
    7021         698 :         if (PyType_Ready(&epm_twr_t_Type) < 0)
    7022           0 :                 goto out;
    7023         698 :         if (PyType_Ready(&epm_entry_t_Type) < 0)
    7024           0 :                 goto out;
    7025         698 :         if (PyType_Ready(&rpc_if_id_t_Type) < 0)
    7026           0 :                 goto out;
    7027         698 :         if (PyType_Ready(&epm_twr_p_t_Type) < 0)
    7028           0 :                 goto out;
    7029         698 :         if (PyType_Ready(&epm_Insert_Type) < 0)
    7030           0 :                 goto out;
    7031         698 :         if (PyType_Ready(&epm_Delete_Type) < 0)
    7032           0 :                 goto out;
    7033         698 :         if (PyType_Ready(&epm_Lookup_Type) < 0)
    7034           0 :                 goto out;
    7035         698 :         if (PyType_Ready(&epm_Map_Type) < 0)
    7036           0 :                 goto out;
    7037         698 :         if (PyType_Ready(&epm_LookupHandleFree_Type) < 0)
    7038           0 :                 goto out;
    7039         698 :         if (PyType_Ready(&epm_InqObject_Type) < 0)
    7040           0 :                 goto out;
    7041         698 :         if (PyType_Ready(&epm_MgmtDelete_Type) < 0)
    7042           0 :                 goto out;
    7043         698 :         if (PyType_Ready(&epmapper_InterfaceType) < 0)
    7044           0 :                 goto out;
    7045         698 :         if (PyType_Ready(&epmapper_SyntaxType) < 0)
    7046           0 :                 goto out;
    7047         698 :         if (!PyInterface_AddNdrRpcMethods(&epmapper_InterfaceType, py_ndr_epmapper_methods))
    7048           0 :                 return NULL;
    7049             : 
    7050             : #ifdef PY_EPM_RHS_DNET_NSP_PATCH
    7051             :         PY_EPM_RHS_DNET_NSP_PATCH(&epm_rhs_dnet_nsp_Type);
    7052             : #endif
    7053             : #ifdef PY_EPM_RHS_OSI_TP4_PATCH
    7054             :         PY_EPM_RHS_OSI_TP4_PATCH(&epm_rhs_osi_tp4_Type);
    7055             : #endif
    7056             : #ifdef PY_EPM_RHS_OSI_CLNS_PATCH
    7057             :         PY_EPM_RHS_OSI_CLNS_PATCH(&epm_rhs_osi_clns_Type);
    7058             : #endif
    7059             : #ifdef PY_EPM_RHS_UDP_PATCH
    7060             :         PY_EPM_RHS_UDP_PATCH(&epm_rhs_udp_Type);
    7061             : #endif
    7062             : #ifdef PY_EPM_RHS_TCP_PATCH
    7063             :         PY_EPM_RHS_TCP_PATCH(&epm_rhs_tcp_Type);
    7064             : #endif
    7065             : #ifdef PY_EPM_RHS_IP_PATCH
    7066             :         PY_EPM_RHS_IP_PATCH(&epm_rhs_ip_Type);
    7067             : #endif
    7068             : #ifdef PY_EPM_RHS_NCADG_PATCH
    7069             :         PY_EPM_RHS_NCADG_PATCH(&epm_rhs_ncadg_Type);
    7070             : #endif
    7071             : #ifdef PY_EPM_RHS_NCACN_PATCH
    7072             :         PY_EPM_RHS_NCACN_PATCH(&epm_rhs_ncacn_Type);
    7073             : #endif
    7074             : #ifdef PY_EPM_RHS_UUID_PATCH
    7075             :         PY_EPM_RHS_UUID_PATCH(&epm_rhs_uuid_Type);
    7076             : #endif
    7077             : #ifdef PY_EPM_RHS_IPX_PATCH
    7078             :         PY_EPM_RHS_IPX_PATCH(&epm_rhs_ipx_Type);
    7079             : #endif
    7080             : #ifdef PY_EPM_RHS_SMB_PATCH
    7081             :         PY_EPM_RHS_SMB_PATCH(&epm_rhs_smb_Type);
    7082             : #endif
    7083             : #ifdef PY_EPM_RHS_NAMED_PIPE_PATCH
    7084             :         PY_EPM_RHS_NAMED_PIPE_PATCH(&epm_rhs_named_pipe_Type);
    7085             : #endif
    7086             : #ifdef PY_EPM_RHS_NETBIOS_PATCH
    7087             :         PY_EPM_RHS_NETBIOS_PATCH(&epm_rhs_netbios_Type);
    7088             : #endif
    7089             : #ifdef PY_EPM_RHS_NETBEUI_PATCH
    7090             :         PY_EPM_RHS_NETBEUI_PATCH(&epm_rhs_netbeui_Type);
    7091             : #endif
    7092             : #ifdef PY_EPM_RHS_SPX_PATCH
    7093             :         PY_EPM_RHS_SPX_PATCH(&epm_rhs_spx_Type);
    7094             : #endif
    7095             : #ifdef PY_EPM_RHS_NB_IPX_PATCH
    7096             :         PY_EPM_RHS_NB_IPX_PATCH(&epm_rhs_nb_ipx_Type);
    7097             : #endif
    7098             : #ifdef PY_EPM_RHS_HTTP_PATCH
    7099             :         PY_EPM_RHS_HTTP_PATCH(&epm_rhs_http_Type);
    7100             : #endif
    7101             : #ifdef PY_EPM_RHS_UNIX_DS_PATCH
    7102             :         PY_EPM_RHS_UNIX_DS_PATCH(&epm_rhs_unix_ds_Type);
    7103             : #endif
    7104             : #ifdef PY_EPM_RHS_NULL_PATCH
    7105             :         PY_EPM_RHS_NULL_PATCH(&epm_rhs_null_Type);
    7106             : #endif
    7107             : #ifdef PY_EPM_RHS_NCALRPC_PATCH
    7108             :         PY_EPM_RHS_NCALRPC_PATCH(&epm_rhs_ncalrpc_Type);
    7109             : #endif
    7110             : #ifdef PY_EPM_RHS_APPLETALK_PATCH
    7111             :         PY_EPM_RHS_APPLETALK_PATCH(&epm_rhs_appletalk_Type);
    7112             : #endif
    7113             : #ifdef PY_EPM_RHS_ATALK_STREAM_PATCH
    7114             :         PY_EPM_RHS_ATALK_STREAM_PATCH(&epm_rhs_atalk_stream_Type);
    7115             : #endif
    7116             : #ifdef PY_EPM_RHS_ATALK_DATAGRAM_PATCH
    7117             :         PY_EPM_RHS_ATALK_DATAGRAM_PATCH(&epm_rhs_atalk_datagram_Type);
    7118             : #endif
    7119             : #ifdef PY_EPM_RHS_VINES_SPP_PATCH
    7120             :         PY_EPM_RHS_VINES_SPP_PATCH(&epm_rhs_vines_spp_Type);
    7121             : #endif
    7122             : #ifdef PY_EPM_RHS_VINES_IPC_PATCH
    7123             :         PY_EPM_RHS_VINES_IPC_PATCH(&epm_rhs_vines_ipc_Type);
    7124             : #endif
    7125             : #ifdef PY_EPM_RHS_STREETTALK_PATCH
    7126             :         PY_EPM_RHS_STREETTALK_PATCH(&epm_rhs_streettalk_Type);
    7127             : #endif
    7128             : #ifdef PY_EPM_RHS_PATCH
    7129             :         PY_EPM_RHS_PATCH(&epm_rhs_Type);
    7130             : #endif
    7131             : #ifdef PY_EPM_LHS_PATCH
    7132             :         PY_EPM_LHS_PATCH(&epm_lhs_Type);
    7133             : #endif
    7134             : #ifdef PY_EPM_FLOOR_PATCH
    7135             :         PY_EPM_FLOOR_PATCH(&epm_floor_Type);
    7136             : #endif
    7137             : #ifdef PY_EPM_TOWER_PATCH
    7138             :         PY_EPM_TOWER_PATCH(&epm_tower_Type);
    7139             : #endif
    7140             : #ifdef PY_EPM_TWR_T_PATCH
    7141             :         PY_EPM_TWR_T_PATCH(&epm_twr_t_Type);
    7142             : #endif
    7143             : #ifdef PY_EPM_ENTRY_T_PATCH
    7144             :         PY_EPM_ENTRY_T_PATCH(&epm_entry_t_Type);
    7145             : #endif
    7146             : #ifdef PY_RPC_IF_ID_T_PATCH
    7147             :         PY_RPC_IF_ID_T_PATCH(&rpc_if_id_t_Type);
    7148             : #endif
    7149             : #ifdef PY_EPM_TWR_P_T_PATCH
    7150             :         PY_EPM_TWR_P_T_PATCH(&epm_twr_p_t_Type);
    7151             : #endif
    7152             : #ifdef PY_EPM_INSERT_PATCH
    7153             :         PY_EPM_INSERT_PATCH(&epm_Insert_Type);
    7154             : #endif
    7155             : #ifdef PY_EPM_DELETE_PATCH
    7156             :         PY_EPM_DELETE_PATCH(&epm_Delete_Type);
    7157             : #endif
    7158             : #ifdef PY_EPM_LOOKUP_PATCH
    7159             :         PY_EPM_LOOKUP_PATCH(&epm_Lookup_Type);
    7160             : #endif
    7161             : #ifdef PY_EPM_MAP_PATCH
    7162             :         PY_EPM_MAP_PATCH(&epm_Map_Type);
    7163             : #endif
    7164             : #ifdef PY_EPM_LOOKUPHANDLEFREE_PATCH
    7165             :         PY_EPM_LOOKUPHANDLEFREE_PATCH(&epm_LookupHandleFree_Type);
    7166             : #endif
    7167             : #ifdef PY_EPM_INQOBJECT_PATCH
    7168             :         PY_EPM_INQOBJECT_PATCH(&epm_InqObject_Type);
    7169             : #endif
    7170             : #ifdef PY_EPM_MGMTDELETE_PATCH
    7171             :         PY_EPM_MGMTDELETE_PATCH(&epm_MgmtDelete_Type);
    7172             : #endif
    7173             : #ifdef PY_EPMAPPER_PATCH
    7174             :         PY_EPMAPPER_PATCH(&epmapper_InterfaceType);
    7175             : #endif
    7176             : #ifdef PY_EPMAPPER_ABSTRACT_SYNTAX_PATCH
    7177             :         PY_EPMAPPER_ABSTRACT_SYNTAX_PATCH(&epmapper_SyntaxType);
    7178             : #endif
    7179             : #ifdef PY_ABSTRACT_SYNTAX_PATCH
    7180             :         PY_ABSTRACT_SYNTAX_PATCH(&epmapper_SyntaxType);
    7181             : #endif
    7182             : 
    7183         698 :         m = PyModule_Create(&moduledef);
    7184         698 :         if (m == NULL)
    7185           0 :                 goto out;
    7186             : 
    7187         698 :         PyModule_AddObject(m, "EPMAPPER_STATUS_CANT_PERFORM_OP", PyLong_FromUnsignedLongLong(0x6d8));
    7188         698 :         PyModule_AddObject(m, "EPMAPPER_STATUS_NO_MORE_ENTRIES", PyLong_FromUnsignedLongLong(0x16c9a0d6));
    7189         698 :         PyModule_AddObject(m, "EPMAPPER_STATUS_NO_MEMORY", PyLong_FromUnsignedLongLong(0x16C9A012));
    7190         698 :         PyModule_AddObject(m, "EPMAPPER_STATUS_OK", PyLong_FromUnsignedLongLong(0));
    7191         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_DNET_NSP", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_DNET_NSP)));
    7192         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_OSI_TP4", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_OSI_TP4)));
    7193         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_OSI_CLNS", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_OSI_CLNS)));
    7194         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_TCP", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_TCP)));
    7195         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_UDP", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_UDP)));
    7196         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_IP", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_IP)));
    7197         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_NCADG", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_NCADG)));
    7198         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_NCACN", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_NCACN)));
    7199         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_NCALRPC", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_NCALRPC)));
    7200         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_UUID", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_UUID)));
    7201         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_IPX", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_IPX)));
    7202         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_SMB", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_SMB)));
    7203         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_NAMED_PIPE", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_NAMED_PIPE)));
    7204         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_NETBIOS", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_NETBIOS)));
    7205         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_NETBEUI", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_NETBEUI)));
    7206         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_SPX", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_SPX)));
    7207         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_NB_IPX", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_NB_IPX)));
    7208         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_DSP", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_DSP)));
    7209         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_DDP", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_DDP)));
    7210         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_APPLETALK", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_APPLETALK)));
    7211         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_VINES_SPP", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_VINES_SPP)));
    7212         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_VINES_IPC", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_VINES_IPC)));
    7213         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_STREETTALK", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_STREETTALK)));
    7214         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_HTTP", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_HTTP)));
    7215         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_UNIX_DS", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_UNIX_DS)));
    7216         698 :         PyModule_AddObject(m, "EPM_PROTOCOL_NULL", PyLong_FromLong((uint16_t)(EPM_PROTOCOL_NULL)));
    7217         698 :         PyModule_AddObject(m, "RPC_C_EP_ALL_ELTS", PyLong_FromUnsignedLongLong((uint32_t)(RPC_C_EP_ALL_ELTS)));
    7218         698 :         PyModule_AddObject(m, "RPC_C_EP_MATCH_BY_IF", PyLong_FromUnsignedLongLong((uint32_t)(RPC_C_EP_MATCH_BY_IF)));
    7219         698 :         PyModule_AddObject(m, "RPC_C_EP_MATCH_BY_OBJ", PyLong_FromUnsignedLongLong((uint32_t)(RPC_C_EP_MATCH_BY_OBJ)));
    7220         698 :         PyModule_AddObject(m, "RPC_C_EP_MATCH_BY_BOTH", PyLong_FromUnsignedLongLong((uint32_t)(RPC_C_EP_MATCH_BY_BOTH)));
    7221         698 :         PyModule_AddObject(m, "RPC_C_VERS_ALL", PyLong_FromUnsignedLongLong((uint32_t)(RPC_C_VERS_ALL)));
    7222         698 :         PyModule_AddObject(m, "RPC_C_VERS_COMPATIBLE", PyLong_FromUnsignedLongLong((uint32_t)(RPC_C_VERS_COMPATIBLE)));
    7223         698 :         PyModule_AddObject(m, "RPC_C_VERS_EXACT", PyLong_FromUnsignedLongLong((uint32_t)(RPC_C_VERS_EXACT)));
    7224         698 :         PyModule_AddObject(m, "RPC_C_VERS_MAJOR_ONLY", PyLong_FromUnsignedLongLong((uint32_t)(RPC_C_VERS_MAJOR_ONLY)));
    7225         698 :         PyModule_AddObject(m, "RPC_C_VERS_UPTO", PyLong_FromUnsignedLongLong((uint32_t)(RPC_C_VERS_UPTO)));
    7226         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_dnet_nsp_Type);
    7227         698 :         PyModule_AddObject(m, "epm_rhs_dnet_nsp", (PyObject *)(void *)&epm_rhs_dnet_nsp_Type);
    7228         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_osi_tp4_Type);
    7229         698 :         PyModule_AddObject(m, "epm_rhs_osi_tp4", (PyObject *)(void *)&epm_rhs_osi_tp4_Type);
    7230         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_osi_clns_Type);
    7231         698 :         PyModule_AddObject(m, "epm_rhs_osi_clns", (PyObject *)(void *)&epm_rhs_osi_clns_Type);
    7232         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_udp_Type);
    7233         698 :         PyModule_AddObject(m, "epm_rhs_udp", (PyObject *)(void *)&epm_rhs_udp_Type);
    7234         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_tcp_Type);
    7235         698 :         PyModule_AddObject(m, "epm_rhs_tcp", (PyObject *)(void *)&epm_rhs_tcp_Type);
    7236         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_ip_Type);
    7237         698 :         PyModule_AddObject(m, "epm_rhs_ip", (PyObject *)(void *)&epm_rhs_ip_Type);
    7238         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_ncadg_Type);
    7239         698 :         PyModule_AddObject(m, "epm_rhs_ncadg", (PyObject *)(void *)&epm_rhs_ncadg_Type);
    7240         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_ncacn_Type);
    7241         698 :         PyModule_AddObject(m, "epm_rhs_ncacn", (PyObject *)(void *)&epm_rhs_ncacn_Type);
    7242         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_uuid_Type);
    7243         698 :         PyModule_AddObject(m, "epm_rhs_uuid", (PyObject *)(void *)&epm_rhs_uuid_Type);
    7244         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_ipx_Type);
    7245         698 :         PyModule_AddObject(m, "epm_rhs_ipx", (PyObject *)(void *)&epm_rhs_ipx_Type);
    7246         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_smb_Type);
    7247         698 :         PyModule_AddObject(m, "epm_rhs_smb", (PyObject *)(void *)&epm_rhs_smb_Type);
    7248         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_named_pipe_Type);
    7249         698 :         PyModule_AddObject(m, "epm_rhs_named_pipe", (PyObject *)(void *)&epm_rhs_named_pipe_Type);
    7250         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_netbios_Type);
    7251         698 :         PyModule_AddObject(m, "epm_rhs_netbios", (PyObject *)(void *)&epm_rhs_netbios_Type);
    7252         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_netbeui_Type);
    7253         698 :         PyModule_AddObject(m, "epm_rhs_netbeui", (PyObject *)(void *)&epm_rhs_netbeui_Type);
    7254         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_spx_Type);
    7255         698 :         PyModule_AddObject(m, "epm_rhs_spx", (PyObject *)(void *)&epm_rhs_spx_Type);
    7256         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_nb_ipx_Type);
    7257         698 :         PyModule_AddObject(m, "epm_rhs_nb_ipx", (PyObject *)(void *)&epm_rhs_nb_ipx_Type);
    7258         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_http_Type);
    7259         698 :         PyModule_AddObject(m, "epm_rhs_http", (PyObject *)(void *)&epm_rhs_http_Type);
    7260         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_unix_ds_Type);
    7261         698 :         PyModule_AddObject(m, "epm_rhs_unix_ds", (PyObject *)(void *)&epm_rhs_unix_ds_Type);
    7262         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_null_Type);
    7263         698 :         PyModule_AddObject(m, "epm_rhs_null", (PyObject *)(void *)&epm_rhs_null_Type);
    7264         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_ncalrpc_Type);
    7265         698 :         PyModule_AddObject(m, "epm_rhs_ncalrpc", (PyObject *)(void *)&epm_rhs_ncalrpc_Type);
    7266         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_appletalk_Type);
    7267         698 :         PyModule_AddObject(m, "epm_rhs_appletalk", (PyObject *)(void *)&epm_rhs_appletalk_Type);
    7268         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_atalk_stream_Type);
    7269         698 :         PyModule_AddObject(m, "epm_rhs_atalk_stream", (PyObject *)(void *)&epm_rhs_atalk_stream_Type);
    7270         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_atalk_datagram_Type);
    7271         698 :         PyModule_AddObject(m, "epm_rhs_atalk_datagram", (PyObject *)(void *)&epm_rhs_atalk_datagram_Type);
    7272         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_vines_spp_Type);
    7273         698 :         PyModule_AddObject(m, "epm_rhs_vines_spp", (PyObject *)(void *)&epm_rhs_vines_spp_Type);
    7274         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_vines_ipc_Type);
    7275         698 :         PyModule_AddObject(m, "epm_rhs_vines_ipc", (PyObject *)(void *)&epm_rhs_vines_ipc_Type);
    7276         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_streettalk_Type);
    7277         698 :         PyModule_AddObject(m, "epm_rhs_streettalk", (PyObject *)(void *)&epm_rhs_streettalk_Type);
    7278         523 :         Py_INCREF((PyObject *)(void *)&epm_rhs_Type);
    7279         698 :         PyModule_AddObject(m, "epm_rhs", (PyObject *)(void *)&epm_rhs_Type);
    7280         523 :         Py_INCREF((PyObject *)(void *)&epm_lhs_Type);
    7281         698 :         PyModule_AddObject(m, "epm_lhs", (PyObject *)(void *)&epm_lhs_Type);
    7282         523 :         Py_INCREF((PyObject *)(void *)&epm_floor_Type);
    7283         698 :         PyModule_AddObject(m, "epm_floor", (PyObject *)(void *)&epm_floor_Type);
    7284         523 :         Py_INCREF((PyObject *)(void *)&epm_tower_Type);
    7285         698 :         PyModule_AddObject(m, "epm_tower", (PyObject *)(void *)&epm_tower_Type);
    7286         523 :         Py_INCREF((PyObject *)(void *)&epm_twr_t_Type);
    7287         698 :         PyModule_AddObject(m, "epm_twr_t", (PyObject *)(void *)&epm_twr_t_Type);
    7288         523 :         Py_INCREF((PyObject *)(void *)&epm_entry_t_Type);
    7289         698 :         PyModule_AddObject(m, "epm_entry_t", (PyObject *)(void *)&epm_entry_t_Type);
    7290         523 :         Py_INCREF((PyObject *)(void *)&rpc_if_id_t_Type);
    7291         698 :         PyModule_AddObject(m, "rpc_if_id_t", (PyObject *)(void *)&rpc_if_id_t_Type);
    7292         523 :         Py_INCREF((PyObject *)(void *)&epm_twr_p_t_Type);
    7293         698 :         PyModule_AddObject(m, "epm_twr_p_t", (PyObject *)(void *)&epm_twr_p_t_Type);
    7294         523 :         Py_INCREF((PyObject *)(void *)&epm_Insert_Type);
    7295         698 :         PyModule_AddObject(m, "epm_Insert", (PyObject *)(void *)&epm_Insert_Type);
    7296         523 :         Py_INCREF((PyObject *)(void *)&epm_Delete_Type);
    7297         698 :         PyModule_AddObject(m, "epm_Delete", (PyObject *)(void *)&epm_Delete_Type);
    7298         523 :         Py_INCREF((PyObject *)(void *)&epm_Lookup_Type);
    7299         698 :         PyModule_AddObject(m, "epm_Lookup", (PyObject *)(void *)&epm_Lookup_Type);
    7300         523 :         Py_INCREF((PyObject *)(void *)&epm_Map_Type);
    7301         698 :         PyModule_AddObject(m, "epm_Map", (PyObject *)(void *)&epm_Map_Type);
    7302         523 :         Py_INCREF((PyObject *)(void *)&epm_LookupHandleFree_Type);
    7303         698 :         PyModule_AddObject(m, "epm_LookupHandleFree", (PyObject *)(void *)&epm_LookupHandleFree_Type);
    7304         523 :         Py_INCREF((PyObject *)(void *)&epm_InqObject_Type);
    7305         698 :         PyModule_AddObject(m, "epm_InqObject", (PyObject *)(void *)&epm_InqObject_Type);
    7306         523 :         Py_INCREF((PyObject *)(void *)&epm_MgmtDelete_Type);
    7307         698 :         PyModule_AddObject(m, "epm_MgmtDelete", (PyObject *)(void *)&epm_MgmtDelete_Type);
    7308         523 :         Py_INCREF((PyObject *)(void *)&epmapper_InterfaceType);
    7309         698 :         PyModule_AddObject(m, "epmapper", (PyObject *)(void *)&epmapper_InterfaceType);
    7310         523 :         Py_INCREF((PyObject *)(void *)&epmapper_SyntaxType);
    7311         698 :         PyModule_AddObject(m, "epmapper_abstract_syntax", (PyObject *)(void *)&epmapper_SyntaxType);
    7312         523 :         Py_INCREF((PyObject *)(void *)&epmapper_SyntaxType);
    7313         698 :         PyModule_AddObject(m, "abstract_syntax", (PyObject *)(void *)&epmapper_SyntaxType);
    7314             : #ifdef PY_MOD_EPMAPPER_PATCH
    7315             :         PY_MOD_EPMAPPER_PATCH(m);
    7316             : #endif
    7317         698 :         out:
    7318         698 :         Py_XDECREF(dep_samba_dcerpc_misc);
    7319         698 :         Py_XDECREF(dep_talloc);
    7320         698 :         Py_XDECREF(dep_samba_dcerpc_base);
    7321         632 :         return m;
    7322             : 
    7323             : }

Generated by: LCOV version 1.14