LCOV - code coverage report
Current view: top level - bin/default/source4/librpc/gen_ndr - py_irpc.c (source / functions) Hit Total Coverage
Test: coverage report for master 2b515b7d Lines: 210 4295 4.9 %
Date: 2024-02-28 12:06:22 Functions: 3 342 0.9 %

          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/source4/librpc/gen_ndr/ndr_irpc.h"
      12             : #include "bin/default/source4/librpc/gen_ndr/ndr_irpc_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           0 : static inline unsigned long long ndr_sizeof2uintmax(size_t var_size)
      33             : {
      34           0 :         switch (var_size) {
      35           0 :         case 8:
      36           0 :                 return UINT64_MAX;
      37           0 :         case 4:
      38           0 :                 return UINT32_MAX;
      39           0 :         case 2:
      40           0 :                 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             : #include "librpc/gen_ndr/security.h"
      66             : #include "librpc/gen_ndr/nbt.h"
      67             : #include "librpc/gen_ndr/netlogon.h"
      68             : #include "librpc/gen_ndr/server_id.h"
      69             : static PyTypeObject irpc_creds_Type;
      70             : static PyTypeObject irpc_header_Type;
      71             : static PyTypeObject irpc_name_record_Type;
      72             : static PyTypeObject irpc_name_records_Type;
      73             : static PyTypeObject nbtd_statistics_Type;
      74             : static PyTypeObject nbtd_info_Type;
      75             : static PyTypeObject nbtd_proxy_wins_addr_Type;
      76             : static PyTypeObject smbsrv_session_info_Type;
      77             : static PyTypeObject smbsrv_sessions_Type;
      78             : static PyTypeObject smbsrv_tcon_info_Type;
      79             : static PyTypeObject smbsrv_tcons_Type;
      80             : static PyTypeObject smbsrv_info_Type;
      81             : static PyTypeObject irpc_InterfaceType;
      82             : static PyTypeObject irpc_uptime_Type;
      83             : static PyTypeObject nbtd_information_Type;
      84             : static PyTypeObject nbtd_getdcname_Type;
      85             : static PyTypeObject nbtd_proxy_wins_challenge_Type;
      86             : static PyTypeObject nbtd_proxy_wins_release_demand_Type;
      87             : static PyTypeObject kdc_check_generic_kerberos_Type;
      88             : static PyTypeObject smbsrv_information_Type;
      89             : static PyTypeObject samba_terminate_Type;
      90             : static PyTypeObject dreplsrv_refresh_Type;
      91             : static PyTypeObject drepl_takeFSMORole_Type;
      92             : static PyTypeObject drepl_trigger_repl_secret_Type;
      93             : static PyTypeObject dnsupdate_RODC_Type;
      94             : static PyTypeObject dnssrv_reload_dns_zones_Type;
      95             : 
      96             : static PyTypeObject *security_token_Type;
      97             : static PyTypeObject *BaseObject_Type;
      98             : static PyTypeObject *GUID_Type;
      99             : static PyTypeObject *server_id_Type;
     100             : static PyTypeObject *dom_sid_Type;
     101             : static PyTypeObject *nbt_name_Type;
     102             : static PyTypeObject *NL_DNS_NAME_INFO_ARRAY_Type;
     103             : static PyTypeObject *ClientConnection_Type;
     104             : static PyTypeObject *ndr_syntax_id_Type;
     105             : 
     106           0 : static PyObject *py_irpc_creds_get_token(PyObject *obj, void *closure)
     107             : {
     108           0 :         struct irpc_creds *object = pytalloc_get_ptr(obj);
     109             :         PyObject *py_token;
     110           0 :         if (object->token == NULL) {
     111           0 :                 Py_RETURN_NONE;
     112             :         }
     113           0 :         if (object->token == NULL) {
     114           0 :                 py_token = Py_None;
     115           0 :                 Py_INCREF(py_token);
     116             :         } else {
     117           0 :                 py_token = pytalloc_reference_ex(security_token_Type, object->token, object->token);
     118             :         }
     119           0 :         return py_token;
     120             : }
     121             : 
     122           0 : static int py_irpc_creds_set_token(PyObject *py_obj, PyObject *value, void *closure)
     123             : {
     124           0 :         struct irpc_creds *object = pytalloc_get_ptr(py_obj);
     125           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->token));
     126           0 :         if (value == NULL) {
     127           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->token");
     128           0 :                 return -1;
     129             :         }
     130           0 :         if (value == Py_None) {
     131           0 :                 object->token = NULL;
     132             :         } else {
     133           0 :                 object->token = NULL;
     134           0 :                 PY_CHECK_TYPE(security_token_Type, value, return -1;);
     135           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
     136           0 :                         PyErr_NoMemory();
     137           0 :                         return -1;
     138             :                 }
     139           0 :                 object->token = (struct security_token *)pytalloc_get_ptr(value);
     140             :         }
     141           0 :         return 0;
     142             : }
     143             : 
     144             : static PyGetSetDef py_irpc_creds_getsetters[] = {
     145             :         {
     146             :                 .name = discard_const_p(char, "token"),
     147             :                 .get = py_irpc_creds_get_token,
     148             :                 .set = py_irpc_creds_set_token,
     149             :                 .doc = discard_const_p(char, "PIDL-generated element of base type security_token")
     150             :         },
     151             :         { .name = NULL }
     152             : };
     153             : 
     154           0 : static PyObject *py_irpc_creds_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     155             : {
     156           0 :         return pytalloc_new(struct irpc_creds, type);
     157             : }
     158             : 
     159             : 
     160             : static PyTypeObject irpc_creds_Type = {
     161             :         PyVarObject_HEAD_INIT(NULL, 0)
     162             :         .tp_name = "irpc.creds",
     163             :         .tp_getset = py_irpc_creds_getsetters,
     164             :         .tp_methods = NULL,
     165             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     166             :         .tp_new = py_irpc_creds_new,
     167             : };
     168             : 
     169             : 
     170           0 : static PyObject *py_irpc_header_get_uuid(PyObject *obj, void *closure)
     171             : {
     172           0 :         struct irpc_header *object = pytalloc_get_ptr(obj);
     173             :         PyObject *py_uuid;
     174           0 :         py_uuid = pytalloc_reference_ex(GUID_Type, pytalloc_get_mem_ctx(obj), &object->uuid);
     175           0 :         return py_uuid;
     176             : }
     177             : 
     178           0 : static int py_irpc_header_set_uuid(PyObject *py_obj, PyObject *value, void *closure)
     179             : {
     180           0 :         struct irpc_header *object = pytalloc_get_ptr(py_obj);
     181           0 :         if (value == NULL) {
     182           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->uuid");
     183           0 :                 return -1;
     184             :         }
     185           0 :         PY_CHECK_TYPE(GUID_Type, value, return -1;);
     186           0 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
     187           0 :                 PyErr_NoMemory();
     188           0 :                 return -1;
     189             :         }
     190           0 :         object->uuid = *(struct GUID *)pytalloc_get_ptr(value);
     191           0 :         return 0;
     192             : }
     193             : 
     194           0 : static PyObject *py_irpc_header_get_if_version(PyObject *obj, void *closure)
     195             : {
     196           0 :         struct irpc_header *object = pytalloc_get_ptr(obj);
     197             :         PyObject *py_if_version;
     198           0 :         py_if_version = PyLong_FromUnsignedLongLong((uint32_t)(object->if_version));
     199           0 :         return py_if_version;
     200             : }
     201             : 
     202           0 : static int py_irpc_header_set_if_version(PyObject *py_obj, PyObject *value, void *closure)
     203             : {
     204           0 :         struct irpc_header *object = pytalloc_get_ptr(py_obj);
     205           0 :         if (value == NULL) {
     206           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->if_version");
     207           0 :                 return -1;
     208             :         }
     209             :         {
     210           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->if_version));
     211           0 :                 if (PyLong_Check(value)) {
     212             :                         unsigned long long test_var;
     213           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
     214           0 :                         if (PyErr_Occurred() != NULL) {
     215           0 :                                 return -1;
     216             :                         }
     217           0 :                         if (test_var > uint_max) {
     218           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
     219             :                                   PyLong_Type.tp_name, uint_max, test_var);
     220           0 :                                 return -1;
     221             :                         }
     222           0 :                         object->if_version = test_var;
     223             :                 } else {
     224           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
     225             :                           PyLong_Type.tp_name);
     226           0 :                         return -1;
     227             :                 }
     228             :         }
     229           0 :         return 0;
     230             : }
     231             : 
     232           0 : static PyObject *py_irpc_header_get_callnum(PyObject *obj, void *closure)
     233             : {
     234           0 :         struct irpc_header *object = pytalloc_get_ptr(obj);
     235             :         PyObject *py_callnum;
     236           0 :         py_callnum = PyLong_FromUnsignedLongLong((uint32_t)(object->callnum));
     237           0 :         return py_callnum;
     238             : }
     239             : 
     240           0 : static int py_irpc_header_set_callnum(PyObject *py_obj, PyObject *value, void *closure)
     241             : {
     242           0 :         struct irpc_header *object = pytalloc_get_ptr(py_obj);
     243           0 :         if (value == NULL) {
     244           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->callnum");
     245           0 :                 return -1;
     246             :         }
     247             :         {
     248           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->callnum));
     249           0 :                 if (PyLong_Check(value)) {
     250             :                         unsigned long long test_var;
     251           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
     252           0 :                         if (PyErr_Occurred() != NULL) {
     253           0 :                                 return -1;
     254             :                         }
     255           0 :                         if (test_var > uint_max) {
     256           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
     257             :                                   PyLong_Type.tp_name, uint_max, test_var);
     258           0 :                                 return -1;
     259             :                         }
     260           0 :                         object->callnum = test_var;
     261             :                 } else {
     262           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
     263             :                           PyLong_Type.tp_name);
     264           0 :                         return -1;
     265             :                 }
     266             :         }
     267           0 :         return 0;
     268             : }
     269             : 
     270           0 : static PyObject *py_irpc_header_get_callid(PyObject *obj, void *closure)
     271             : {
     272           0 :         struct irpc_header *object = pytalloc_get_ptr(obj);
     273             :         PyObject *py_callid;
     274           0 :         py_callid = PyLong_FromUnsignedLongLong((uint32_t)(object->callid));
     275           0 :         return py_callid;
     276             : }
     277             : 
     278           0 : static int py_irpc_header_set_callid(PyObject *py_obj, PyObject *value, void *closure)
     279             : {
     280           0 :         struct irpc_header *object = pytalloc_get_ptr(py_obj);
     281           0 :         if (value == NULL) {
     282           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->callid");
     283           0 :                 return -1;
     284             :         }
     285             :         {
     286           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->callid));
     287           0 :                 if (PyLong_Check(value)) {
     288             :                         unsigned long long test_var;
     289           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
     290           0 :                         if (PyErr_Occurred() != NULL) {
     291           0 :                                 return -1;
     292             :                         }
     293           0 :                         if (test_var > uint_max) {
     294           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
     295             :                                   PyLong_Type.tp_name, uint_max, test_var);
     296           0 :                                 return -1;
     297             :                         }
     298           0 :                         object->callid = test_var;
     299             :                 } else {
     300           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
     301             :                           PyLong_Type.tp_name);
     302           0 :                         return -1;
     303             :                 }
     304             :         }
     305           0 :         return 0;
     306             : }
     307             : 
     308           0 : static PyObject *py_irpc_header_get_flags(PyObject *obj, void *closure)
     309             : {
     310           0 :         struct irpc_header *object = pytalloc_get_ptr(obj);
     311             :         PyObject *py_flags;
     312           0 :         py_flags = PyLong_FromUnsignedLongLong((uint32_t)(object->flags));
     313           0 :         return py_flags;
     314             : }
     315             : 
     316           0 : static int py_irpc_header_set_flags(PyObject *py_obj, PyObject *value, void *closure)
     317             : {
     318           0 :         struct irpc_header *object = pytalloc_get_ptr(py_obj);
     319           0 :         if (value == NULL) {
     320           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->flags");
     321           0 :                 return -1;
     322             :         }
     323             :         {
     324           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->flags));
     325           0 :                 if (PyLong_Check(value)) {
     326             :                         unsigned long long test_var;
     327           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
     328           0 :                         if (PyErr_Occurred() != NULL) {
     329           0 :                                 return -1;
     330             :                         }
     331           0 :                         if (test_var > uint_max) {
     332           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
     333             :                                   PyLong_Type.tp_name, uint_max, test_var);
     334           0 :                                 return -1;
     335             :                         }
     336           0 :                         object->flags = test_var;
     337             :                 } else {
     338           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
     339             :                           PyLong_Type.tp_name);
     340           0 :                         return -1;
     341             :                 }
     342             :         }
     343           0 :         return 0;
     344             : }
     345             : 
     346           0 : static PyObject *py_irpc_header_get_status(PyObject *obj, void *closure)
     347             : {
     348           0 :         struct irpc_header *object = pytalloc_get_ptr(obj);
     349             :         PyObject *py_status;
     350           0 :         py_status = PyErr_FromNTSTATUS(object->status);
     351           0 :         return py_status;
     352             : }
     353             : 
     354           0 : static int py_irpc_header_set_status(PyObject *py_obj, PyObject *value, void *closure)
     355             : {
     356           0 :         struct irpc_header *object = pytalloc_get_ptr(py_obj);
     357           0 :         if (value == NULL) {
     358           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->status");
     359           0 :                 return -1;
     360             :         }
     361           0 :         object->status = NT_STATUS(PyLong_AsLong(value));
     362           0 :         return 0;
     363             : }
     364             : 
     365           0 : static PyObject *py_irpc_header_get_creds(PyObject *obj, void *closure)
     366             : {
     367           0 :         struct irpc_header *object = pytalloc_get_ptr(obj);
     368             :         PyObject *py_creds;
     369           0 :         py_creds = pytalloc_reference_ex(&irpc_creds_Type, pytalloc_get_mem_ctx(obj), &object->creds);
     370           0 :         return py_creds;
     371             : }
     372             : 
     373           0 : static int py_irpc_header_set_creds(PyObject *py_obj, PyObject *value, void *closure)
     374             : {
     375           0 :         struct irpc_header *object = pytalloc_get_ptr(py_obj);
     376           0 :         if (value == NULL) {
     377           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->creds");
     378           0 :                 return -1;
     379             :         }
     380           0 :         PY_CHECK_TYPE(&irpc_creds_Type, value, return -1;);
     381           0 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
     382           0 :                 PyErr_NoMemory();
     383           0 :                 return -1;
     384             :         }
     385           0 :         object->creds = *(struct irpc_creds *)pytalloc_get_ptr(value);
     386           0 :         return 0;
     387             : }
     388             : 
     389           0 : static PyObject *py_irpc_header_get__pad(PyObject *obj, void *closure)
     390             : {
     391           0 :         struct irpc_header *object = pytalloc_get_ptr(obj);
     392             :         PyObject *py__pad;
     393           0 :         py__pad = PyBytes_FromStringAndSize((char *)(object->_pad).data, (object->_pad).length);
     394           0 :         return py__pad;
     395             : }
     396             : 
     397           0 : static int py_irpc_header_set__pad(PyObject *py_obj, PyObject *value, void *closure)
     398             : {
     399           0 :         struct irpc_header *object = pytalloc_get_ptr(py_obj);
     400           0 :         if (value == NULL) {
     401           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->_pad");
     402           0 :                 return -1;
     403             :         }
     404           0 :         object->_pad = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyBytes_AS_STRING(value), PyBytes_GET_SIZE(value));
     405           0 :         return 0;
     406             : }
     407             : 
     408             : static PyGetSetDef py_irpc_header_getsetters[] = {
     409             :         {
     410             :                 .name = discard_const_p(char, "uuid"),
     411             :                 .get = py_irpc_header_get_uuid,
     412             :                 .set = py_irpc_header_set_uuid,
     413             :                 .doc = discard_const_p(char, "PIDL-generated element of base type GUID")
     414             :         },
     415             :         {
     416             :                 .name = discard_const_p(char, "if_version"),
     417             :                 .get = py_irpc_header_get_if_version,
     418             :                 .set = py_irpc_header_set_if_version,
     419             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
     420             :         },
     421             :         {
     422             :                 .name = discard_const_p(char, "callnum"),
     423             :                 .get = py_irpc_header_get_callnum,
     424             :                 .set = py_irpc_header_set_callnum,
     425             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
     426             :         },
     427             :         {
     428             :                 .name = discard_const_p(char, "callid"),
     429             :                 .get = py_irpc_header_get_callid,
     430             :                 .set = py_irpc_header_set_callid,
     431             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
     432             :         },
     433             :         {
     434             :                 .name = discard_const_p(char, "flags"),
     435             :                 .get = py_irpc_header_get_flags,
     436             :                 .set = py_irpc_header_set_flags,
     437             :                 .doc = discard_const_p(char, "PIDL-generated element of base type irpc_flags")
     438             :         },
     439             :         {
     440             :                 .name = discard_const_p(char, "status"),
     441             :                 .get = py_irpc_header_get_status,
     442             :                 .set = py_irpc_header_set_status,
     443             :                 .doc = discard_const_p(char, "PIDL-generated element of base type NTSTATUS")
     444             :         },
     445             :         {
     446             :                 .name = discard_const_p(char, "creds"),
     447             :                 .get = py_irpc_header_get_creds,
     448             :                 .set = py_irpc_header_set_creds,
     449             :                 .doc = discard_const_p(char, "PIDL-generated element of base type irpc_creds")
     450             :         },
     451             :         {
     452             :                 .name = discard_const_p(char, "_pad"),
     453             :                 .get = py_irpc_header_get__pad,
     454             :                 .set = py_irpc_header_set__pad,
     455             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DATA_BLOB")
     456             :         },
     457             :         { .name = NULL }
     458             : };
     459             : 
     460           0 : static PyObject *py_irpc_header_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     461             : {
     462           0 :         return pytalloc_new(struct irpc_header, type);
     463             : }
     464             : 
     465           0 : static PyObject *py_irpc_header_ndr_pack(PyObject *py_obj,  PyObject *Py_UNUSED(ignored))
     466             : {
     467           0 :         struct irpc_header *object = pytalloc_get_ptr(py_obj);
     468           0 :         PyObject *ret = NULL;
     469             :         DATA_BLOB blob;
     470             :         enum ndr_err_code err;
     471           0 :         TALLOC_CTX *tmp_ctx = talloc_new(pytalloc_get_mem_ctx(py_obj));
     472           0 :         if (tmp_ctx == NULL) {
     473           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
     474           0 :                 return NULL;
     475             :         }
     476           0 :         err = ndr_push_struct_blob(&blob, tmp_ctx, object, (ndr_push_flags_fn_t)ndr_push_irpc_header);
     477           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
     478           0 :                 TALLOC_FREE(tmp_ctx);
     479           0 :                 PyErr_SetNdrError(err);
     480           0 :                 return NULL;
     481             :         }
     482             : 
     483           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
     484           0 :         TALLOC_FREE(tmp_ctx);
     485           0 :         return ret;
     486             : }
     487             : 
     488           0 : static PyObject *py_irpc_header_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
     489             : {
     490           0 :         struct irpc_header *object = pytalloc_get_ptr(py_obj);
     491           0 :         DATA_BLOB blob = {.data = NULL, .length = 0};
     492           0 :         Py_ssize_t blob_length = 0;
     493             :         enum ndr_err_code err;
     494           0 :         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
     495           0 :         PyObject *allow_remaining_obj = NULL;
     496           0 :         bool allow_remaining = false;
     497             : 
     498           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|O:__ndr_unpack__",
     499             :                 discard_const_p(char *, kwnames),
     500             :                 &blob.data, &blob_length,
     501             :                 &allow_remaining_obj)) {
     502           0 :                 return NULL;
     503             :         }
     504           0 :         blob.length = blob_length;
     505             : 
     506           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
     507           0 :                 allow_remaining = true;
     508             :         }
     509             : 
     510           0 :         if (allow_remaining) {
     511           0 :                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_irpc_header);
     512             :         } else {
     513           0 :                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_irpc_header);
     514             :         }
     515           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
     516           0 :                 PyErr_SetNdrError(err);
     517           0 :                 return NULL;
     518             :         }
     519             : 
     520           0 :         Py_RETURN_NONE;
     521             : }
     522             : 
     523           0 : static PyObject *py_irpc_header_ndr_print(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
     524             : {
     525           0 :         struct irpc_header *object = pytalloc_get_ptr(py_obj);
     526             :         PyObject *ret;
     527             :         char *retstr;
     528             : 
     529           0 :         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_irpc_header, "irpc_header", object);
     530           0 :         ret = PyUnicode_FromString(retstr);
     531           0 :         talloc_free(retstr);
     532             : 
     533           0 :         return ret;
     534             : }
     535             : 
     536             : static PyMethodDef py_irpc_header_methods[] = {
     537             :         { "__ndr_pack__", (PyCFunction)py_irpc_header_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
     538             :         { "__ndr_unpack__", PY_DISCARD_FUNC_SIG(PyCFunction,py_irpc_header_ndr_unpack), METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
     539             :         { "__ndr_print__", (PyCFunction)py_irpc_header_ndr_print, METH_NOARGS, "S.ndr_print(object) -> None\nNDR print" },
     540             :         { NULL, NULL, 0, NULL }
     541             : };
     542             : 
     543             : 
     544             : static PyTypeObject irpc_header_Type = {
     545             :         PyVarObject_HEAD_INIT(NULL, 0)
     546             :         .tp_name = "irpc.header",
     547             :         .tp_getset = py_irpc_header_getsetters,
     548             :         .tp_methods = py_irpc_header_methods,
     549             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     550             :         .tp_new = py_irpc_header_new,
     551             : };
     552             : 
     553             : 
     554        8474 : static PyObject *py_irpc_name_record_get_name(PyObject *obj, void *closure)
     555             : {
     556        8474 :         struct irpc_name_record *object = pytalloc_get_ptr(obj);
     557             :         PyObject *py_name;
     558        8474 :         py_name = PyString_FromStringOrNULL(object->name);
     559        8474 :         return py_name;
     560             : }
     561             : 
     562           0 : static int py_irpc_name_record_set_name(PyObject *py_obj, PyObject *value, void *closure)
     563             : {
     564           0 :         struct irpc_name_record *object = pytalloc_get_ptr(py_obj);
     565           0 :         if (value == NULL) {
     566           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->name");
     567           0 :                 return -1;
     568             :         }
     569             :         {
     570             :                 const char *test_str;
     571             :                 const char *talloc_str;
     572           0 :                 PyObject *unicode = NULL;
     573           0 :                 if (PyUnicode_Check(value)) {
     574           0 :                         unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
     575           0 :                         if (unicode == NULL) {
     576           0 :                                 return -1;
     577             :                         }
     578           0 :                         test_str = PyBytes_AS_STRING(unicode);
     579           0 :                 } else if (PyBytes_Check(value)) {
     580           0 :                         test_str = PyBytes_AS_STRING(value);
     581             :                 } else {
     582           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
     583           0 :                         return -1;
     584             :                 }
     585           0 :                 talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
     586           0 :                 if (unicode != NULL) {
     587           0 :                         Py_DECREF(unicode);
     588             :                 }
     589           0 :                 if (talloc_str == NULL) {
     590           0 :                         PyErr_NoMemory();
     591           0 :                         return -1;
     592             :                 }
     593           0 :                 object->name = talloc_str;
     594             :         }
     595           0 :         return 0;
     596             : }
     597             : 
     598           0 : static PyObject *py_irpc_name_record_get_count(PyObject *obj, void *closure)
     599             : {
     600           0 :         struct irpc_name_record *object = pytalloc_get_ptr(obj);
     601             :         PyObject *py_count;
     602           0 :         py_count = PyLong_FromUnsignedLongLong((uint32_t)(object->count));
     603           0 :         return py_count;
     604             : }
     605             : 
     606           0 : static int py_irpc_name_record_set_count(PyObject *py_obj, PyObject *value, void *closure)
     607             : {
     608           0 :         struct irpc_name_record *object = pytalloc_get_ptr(py_obj);
     609           0 :         if (value == NULL) {
     610           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->count");
     611           0 :                 return -1;
     612             :         }
     613             :         {
     614           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->count));
     615           0 :                 if (PyLong_Check(value)) {
     616             :                         unsigned long long test_var;
     617           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
     618           0 :                         if (PyErr_Occurred() != NULL) {
     619           0 :                                 return -1;
     620             :                         }
     621           0 :                         if (test_var > uint_max) {
     622           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
     623             :                                   PyLong_Type.tp_name, uint_max, test_var);
     624           0 :                                 return -1;
     625             :                         }
     626           0 :                         object->count = test_var;
     627             :                 } else {
     628           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
     629             :                           PyLong_Type.tp_name);
     630           0 :                         return -1;
     631             :                 }
     632             :         }
     633           0 :         return 0;
     634             : }
     635             : 
     636        6927 : static PyObject *py_irpc_name_record_get_ids(PyObject *obj, void *closure)
     637             : {
     638        6927 :         struct irpc_name_record *object = pytalloc_get_ptr(obj);
     639             :         PyObject *py_ids;
     640        6927 :         py_ids = PyList_New(object->count);
     641        6927 :         if (py_ids == NULL) {
     642           0 :                 return NULL;
     643             :         }
     644             :         {
     645             :                 int ids_cntr_0;
     646       15101 :                 for (ids_cntr_0 = 0; ids_cntr_0 < (object->count); ids_cntr_0++) {
     647             :                         PyObject *py_ids_0;
     648        8174 :                         py_ids_0 = pytalloc_reference_ex(server_id_Type, object->ids, &(object->ids)[ids_cntr_0]);
     649        8174 :                         PyList_SetItem(py_ids, ids_cntr_0, py_ids_0);
     650             :                 }
     651             :         }
     652        6927 :         return py_ids;
     653             : }
     654             : 
     655           0 : static int py_irpc_name_record_set_ids(PyObject *py_obj, PyObject *value, void *closure)
     656             : {
     657           0 :         struct irpc_name_record *object = pytalloc_get_ptr(py_obj);
     658           0 :         if (value == NULL) {
     659           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->ids");
     660           0 :                 return -1;
     661             :         }
     662           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
     663             :         {
     664             :                 int ids_cntr_0;
     665           0 :                 object->ids = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->ids, PyList_GET_SIZE(value));
     666           0 :                 if (!object->ids) { return -1; }
     667           0 :                 talloc_set_name_const(object->ids, "ARRAY: object->ids");
     668           0 :                 for (ids_cntr_0 = 0; ids_cntr_0 < PyList_GET_SIZE(value); ids_cntr_0++) {
     669           0 :                         if (PyList_GET_ITEM(value, ids_cntr_0) == NULL) {
     670           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->ids)[ids_cntr_0]");
     671           0 :                                 return -1;
     672             :                         }
     673           0 :                         PY_CHECK_TYPE(server_id_Type, PyList_GET_ITEM(value, ids_cntr_0), return -1;);
     674           0 :                         if (talloc_reference(object->ids, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, ids_cntr_0))) == NULL) {
     675           0 :                                 PyErr_NoMemory();
     676           0 :                                 return -1;
     677             :                         }
     678           0 :                         (object->ids)[ids_cntr_0] = *(struct server_id *)pytalloc_get_ptr(PyList_GET_ITEM(value, ids_cntr_0));
     679             :                 }
     680             :         }
     681           0 :         return 0;
     682             : }
     683             : 
     684             : static PyGetSetDef py_irpc_name_record_getsetters[] = {
     685             :         {
     686             :                 .name = discard_const_p(char, "name"),
     687             :                 .get = py_irpc_name_record_get_name,
     688             :                 .set = py_irpc_name_record_set_name,
     689             :                 .doc = discard_const_p(char, "PIDL-generated element of base type string")
     690             :         },
     691             :         {
     692             :                 .name = discard_const_p(char, "count"),
     693             :                 .get = py_irpc_name_record_get_count,
     694             :                 .set = py_irpc_name_record_set_count,
     695             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
     696             :         },
     697             :         {
     698             :                 .name = discard_const_p(char, "ids"),
     699             :                 .get = py_irpc_name_record_get_ids,
     700             :                 .set = py_irpc_name_record_set_ids,
     701             :                 .doc = discard_const_p(char, "PIDL-generated element of base type server_id")
     702             :         },
     703             :         { .name = NULL }
     704             : };
     705             : 
     706           0 : static PyObject *py_irpc_name_record_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     707             : {
     708           0 :         return pytalloc_new(struct irpc_name_record, type);
     709             : }
     710             : 
     711           0 : static PyObject *py_irpc_name_record_ndr_pack(PyObject *py_obj,  PyObject *Py_UNUSED(ignored))
     712             : {
     713           0 :         struct irpc_name_record *object = pytalloc_get_ptr(py_obj);
     714           0 :         PyObject *ret = NULL;
     715             :         DATA_BLOB blob;
     716             :         enum ndr_err_code err;
     717           0 :         TALLOC_CTX *tmp_ctx = talloc_new(pytalloc_get_mem_ctx(py_obj));
     718           0 :         if (tmp_ctx == NULL) {
     719           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
     720           0 :                 return NULL;
     721             :         }
     722           0 :         err = ndr_push_struct_blob(&blob, tmp_ctx, object, (ndr_push_flags_fn_t)ndr_push_irpc_name_record);
     723           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
     724           0 :                 TALLOC_FREE(tmp_ctx);
     725           0 :                 PyErr_SetNdrError(err);
     726           0 :                 return NULL;
     727             :         }
     728             : 
     729           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
     730           0 :         TALLOC_FREE(tmp_ctx);
     731           0 :         return ret;
     732             : }
     733             : 
     734           0 : static PyObject *py_irpc_name_record_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
     735             : {
     736           0 :         struct irpc_name_record *object = pytalloc_get_ptr(py_obj);
     737           0 :         DATA_BLOB blob = {.data = NULL, .length = 0};
     738           0 :         Py_ssize_t blob_length = 0;
     739             :         enum ndr_err_code err;
     740           0 :         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
     741           0 :         PyObject *allow_remaining_obj = NULL;
     742           0 :         bool allow_remaining = false;
     743             : 
     744           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|O:__ndr_unpack__",
     745             :                 discard_const_p(char *, kwnames),
     746             :                 &blob.data, &blob_length,
     747             :                 &allow_remaining_obj)) {
     748           0 :                 return NULL;
     749             :         }
     750           0 :         blob.length = blob_length;
     751             : 
     752           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
     753           0 :                 allow_remaining = true;
     754             :         }
     755             : 
     756           0 :         if (allow_remaining) {
     757           0 :                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_irpc_name_record);
     758             :         } else {
     759           0 :                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_irpc_name_record);
     760             :         }
     761           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
     762           0 :                 PyErr_SetNdrError(err);
     763           0 :                 return NULL;
     764             :         }
     765             : 
     766           0 :         Py_RETURN_NONE;
     767             : }
     768             : 
     769           0 : static PyObject *py_irpc_name_record_ndr_print(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
     770             : {
     771           0 :         struct irpc_name_record *object = pytalloc_get_ptr(py_obj);
     772             :         PyObject *ret;
     773             :         char *retstr;
     774             : 
     775           0 :         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_irpc_name_record, "irpc_name_record", object);
     776           0 :         ret = PyUnicode_FromString(retstr);
     777           0 :         talloc_free(retstr);
     778             : 
     779           0 :         return ret;
     780             : }
     781             : 
     782             : static PyMethodDef py_irpc_name_record_methods[] = {
     783             :         { "__ndr_pack__", (PyCFunction)py_irpc_name_record_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
     784             :         { "__ndr_unpack__", PY_DISCARD_FUNC_SIG(PyCFunction,py_irpc_name_record_ndr_unpack), METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
     785             :         { "__ndr_print__", (PyCFunction)py_irpc_name_record_ndr_print, METH_NOARGS, "S.ndr_print(object) -> None\nNDR print" },
     786             :         { NULL, NULL, 0, NULL }
     787             : };
     788             : 
     789             : 
     790             : static PyTypeObject irpc_name_record_Type = {
     791             :         PyVarObject_HEAD_INIT(NULL, 0)
     792             :         .tp_name = "irpc.name_record",
     793             :         .tp_getset = py_irpc_name_record_getsetters,
     794             :         .tp_methods = py_irpc_name_record_methods,
     795             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     796             :         .tp_new = py_irpc_name_record_new,
     797             : };
     798             : 
     799             : 
     800           0 : static PyObject *py_irpc_name_records_get_names(PyObject *obj, void *closure)
     801             : {
     802           0 :         struct irpc_name_records *object = pytalloc_get_ptr(obj);
     803             :         PyObject *py_names;
     804           0 :         py_names = PyList_New(object->num_records);
     805           0 :         if (py_names == NULL) {
     806           0 :                 return NULL;
     807             :         }
     808             :         {
     809             :                 int names_cntr_0;
     810           0 :                 for (names_cntr_0 = 0; names_cntr_0 < (object->num_records); names_cntr_0++) {
     811             :                         PyObject *py_names_0;
     812           0 :                         if ((object->names)[names_cntr_0] == NULL) {
     813           0 :                                 py_names_0 = Py_None;
     814           0 :                                 Py_INCREF(py_names_0);
     815             :                         } else {
     816           0 :                                 py_names_0 = pytalloc_reference_ex(&irpc_name_record_Type, (object->names)[names_cntr_0], (object->names)[names_cntr_0]);
     817             :                         }
     818           0 :                         PyList_SetItem(py_names, names_cntr_0, py_names_0);
     819             :                 }
     820             :         }
     821           0 :         return py_names;
     822             : }
     823             : 
     824           0 : static int py_irpc_name_records_set_names(PyObject *py_obj, PyObject *value, void *closure)
     825             : {
     826           0 :         struct irpc_name_records *object = pytalloc_get_ptr(py_obj);
     827           0 :         if (value == NULL) {
     828           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->names");
     829           0 :                 return -1;
     830             :         }
     831           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
     832             :         {
     833             :                 int names_cntr_0;
     834           0 :                 object->names = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->names, PyList_GET_SIZE(value));
     835           0 :                 if (!object->names) { return -1; }
     836           0 :                 talloc_set_name_const(object->names, "ARRAY: object->names");
     837           0 :                 for (names_cntr_0 = 0; names_cntr_0 < PyList_GET_SIZE(value); names_cntr_0++) {
     838           0 :                         if (PyList_GET_ITEM(value, names_cntr_0) == NULL) {
     839           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->names)[names_cntr_0]");
     840           0 :                                 return -1;
     841             :                         }
     842           0 :                         if (PyList_GET_ITEM(value, names_cntr_0) == Py_None) {
     843           0 :                                 (object->names)[names_cntr_0] = NULL;
     844             :                         } else {
     845           0 :                                 (object->names)[names_cntr_0] = NULL;
     846           0 :                                 PY_CHECK_TYPE(&irpc_name_record_Type, PyList_GET_ITEM(value, names_cntr_0), return -1;);
     847           0 :                                 if (talloc_reference(object->names, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, names_cntr_0))) == NULL) {
     848           0 :                                         PyErr_NoMemory();
     849           0 :                                         return -1;
     850             :                                 }
     851           0 :                                 (object->names)[names_cntr_0] = (struct irpc_name_record *)pytalloc_get_ptr(PyList_GET_ITEM(value, names_cntr_0));
     852             :                         }
     853             :                 }
     854             :         }
     855           0 :         return 0;
     856             : }
     857             : 
     858           0 : static PyObject *py_irpc_name_records_get_num_records(PyObject *obj, void *closure)
     859             : {
     860           0 :         struct irpc_name_records *object = pytalloc_get_ptr(obj);
     861             :         PyObject *py_num_records;
     862           0 :         py_num_records = PyLong_FromUnsignedLongLong((uint32_t)(object->num_records));
     863           0 :         return py_num_records;
     864             : }
     865             : 
     866           0 : static int py_irpc_name_records_set_num_records(PyObject *py_obj, PyObject *value, void *closure)
     867             : {
     868           0 :         struct irpc_name_records *object = pytalloc_get_ptr(py_obj);
     869           0 :         if (value == NULL) {
     870           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->num_records");
     871           0 :                 return -1;
     872             :         }
     873             :         {
     874           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->num_records));
     875           0 :                 if (PyLong_Check(value)) {
     876             :                         unsigned long long test_var;
     877           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
     878           0 :                         if (PyErr_Occurred() != NULL) {
     879           0 :                                 return -1;
     880             :                         }
     881           0 :                         if (test_var > uint_max) {
     882           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
     883             :                                   PyLong_Type.tp_name, uint_max, test_var);
     884           0 :                                 return -1;
     885             :                         }
     886           0 :                         object->num_records = test_var;
     887             :                 } else {
     888           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
     889             :                           PyLong_Type.tp_name);
     890           0 :                         return -1;
     891             :                 }
     892             :         }
     893           0 :         return 0;
     894             : }
     895             : 
     896             : static PyGetSetDef py_irpc_name_records_getsetters[] = {
     897             :         {
     898             :                 .name = discard_const_p(char, "names"),
     899             :                 .get = py_irpc_name_records_get_names,
     900             :                 .set = py_irpc_name_records_set_names,
     901             :                 .doc = discard_const_p(char, "PIDL-generated element of base type irpc_name_record")
     902             :         },
     903             :         {
     904             :                 .name = discard_const_p(char, "num_records"),
     905             :                 .get = py_irpc_name_records_get_num_records,
     906             :                 .set = py_irpc_name_records_set_num_records,
     907             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
     908             :         },
     909             :         { .name = NULL }
     910             : };
     911             : 
     912           0 : static PyObject *py_irpc_name_records_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     913             : {
     914           0 :         return pytalloc_new(struct irpc_name_records, type);
     915             : }
     916             : 
     917           0 : static PyObject *py_irpc_name_records_ndr_pack(PyObject *py_obj,  PyObject *Py_UNUSED(ignored))
     918             : {
     919           0 :         struct irpc_name_records *object = pytalloc_get_ptr(py_obj);
     920           0 :         PyObject *ret = NULL;
     921             :         DATA_BLOB blob;
     922             :         enum ndr_err_code err;
     923           0 :         TALLOC_CTX *tmp_ctx = talloc_new(pytalloc_get_mem_ctx(py_obj));
     924           0 :         if (tmp_ctx == NULL) {
     925           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
     926           0 :                 return NULL;
     927             :         }
     928           0 :         err = ndr_push_struct_blob(&blob, tmp_ctx, object, (ndr_push_flags_fn_t)ndr_push_irpc_name_records);
     929           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
     930           0 :                 TALLOC_FREE(tmp_ctx);
     931           0 :                 PyErr_SetNdrError(err);
     932           0 :                 return NULL;
     933             :         }
     934             : 
     935           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
     936           0 :         TALLOC_FREE(tmp_ctx);
     937           0 :         return ret;
     938             : }
     939             : 
     940           0 : static PyObject *py_irpc_name_records_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
     941             : {
     942           0 :         struct irpc_name_records *object = pytalloc_get_ptr(py_obj);
     943           0 :         DATA_BLOB blob = {.data = NULL, .length = 0};
     944           0 :         Py_ssize_t blob_length = 0;
     945             :         enum ndr_err_code err;
     946           0 :         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
     947           0 :         PyObject *allow_remaining_obj = NULL;
     948           0 :         bool allow_remaining = false;
     949             : 
     950           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|O:__ndr_unpack__",
     951             :                 discard_const_p(char *, kwnames),
     952             :                 &blob.data, &blob_length,
     953             :                 &allow_remaining_obj)) {
     954           0 :                 return NULL;
     955             :         }
     956           0 :         blob.length = blob_length;
     957             : 
     958           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
     959           0 :                 allow_remaining = true;
     960             :         }
     961             : 
     962           0 :         if (allow_remaining) {
     963           0 :                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_irpc_name_records);
     964             :         } else {
     965           0 :                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_irpc_name_records);
     966             :         }
     967           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
     968           0 :                 PyErr_SetNdrError(err);
     969           0 :                 return NULL;
     970             :         }
     971             : 
     972           0 :         Py_RETURN_NONE;
     973             : }
     974             : 
     975           0 : static PyObject *py_irpc_name_records_ndr_print(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
     976             : {
     977           0 :         struct irpc_name_records *object = pytalloc_get_ptr(py_obj);
     978             :         PyObject *ret;
     979             :         char *retstr;
     980             : 
     981           0 :         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_irpc_name_records, "irpc_name_records", object);
     982           0 :         ret = PyUnicode_FromString(retstr);
     983           0 :         talloc_free(retstr);
     984             : 
     985           0 :         return ret;
     986             : }
     987             : 
     988             : static PyMethodDef py_irpc_name_records_methods[] = {
     989             :         { "__ndr_pack__", (PyCFunction)py_irpc_name_records_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
     990             :         { "__ndr_unpack__", PY_DISCARD_FUNC_SIG(PyCFunction,py_irpc_name_records_ndr_unpack), METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
     991             :         { "__ndr_print__", (PyCFunction)py_irpc_name_records_ndr_print, METH_NOARGS, "S.ndr_print(object) -> None\nNDR print" },
     992             :         { NULL, NULL, 0, NULL }
     993             : };
     994             : 
     995             : 
     996             : static PyTypeObject irpc_name_records_Type = {
     997             :         PyVarObject_HEAD_INIT(NULL, 0)
     998             :         .tp_name = "irpc.name_records",
     999             :         .tp_getset = py_irpc_name_records_getsetters,
    1000             :         .tp_methods = py_irpc_name_records_methods,
    1001             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    1002             :         .tp_new = py_irpc_name_records_new,
    1003             : };
    1004             : 
    1005             : 
    1006           0 : static PyObject *py_nbtd_statistics_get_total_received(PyObject *obj, void *closure)
    1007             : {
    1008           0 :         struct nbtd_statistics *object = pytalloc_get_ptr(obj);
    1009             :         PyObject *py_total_received;
    1010           0 :         py_total_received = PyLong_FromUnsignedLongLong(object->total_received);
    1011           0 :         return py_total_received;
    1012             : }
    1013             : 
    1014           0 : static int py_nbtd_statistics_set_total_received(PyObject *py_obj, PyObject *value, void *closure)
    1015             : {
    1016           0 :         struct nbtd_statistics *object = pytalloc_get_ptr(py_obj);
    1017           0 :         if (value == NULL) {
    1018           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->total_received");
    1019           0 :                 return -1;
    1020             :         }
    1021             :         {
    1022           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->total_received));
    1023           0 :                 if (PyLong_Check(value)) {
    1024             :                         unsigned long long test_var;
    1025           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    1026           0 :                         if (PyErr_Occurred() != NULL) {
    1027           0 :                                 return -1;
    1028             :                         }
    1029           0 :                         if (test_var > uint_max) {
    1030           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    1031             :                                   PyLong_Type.tp_name, uint_max, test_var);
    1032           0 :                                 return -1;
    1033             :                         }
    1034           0 :                         object->total_received = test_var;
    1035             :                 } else {
    1036           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1037             :                           PyLong_Type.tp_name);
    1038           0 :                         return -1;
    1039             :                 }
    1040             :         }
    1041           0 :         return 0;
    1042             : }
    1043             : 
    1044           0 : static PyObject *py_nbtd_statistics_get_total_sent(PyObject *obj, void *closure)
    1045             : {
    1046           0 :         struct nbtd_statistics *object = pytalloc_get_ptr(obj);
    1047             :         PyObject *py_total_sent;
    1048           0 :         py_total_sent = PyLong_FromUnsignedLongLong(object->total_sent);
    1049           0 :         return py_total_sent;
    1050             : }
    1051             : 
    1052           0 : static int py_nbtd_statistics_set_total_sent(PyObject *py_obj, PyObject *value, void *closure)
    1053             : {
    1054           0 :         struct nbtd_statistics *object = pytalloc_get_ptr(py_obj);
    1055           0 :         if (value == NULL) {
    1056           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->total_sent");
    1057           0 :                 return -1;
    1058             :         }
    1059             :         {
    1060           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->total_sent));
    1061           0 :                 if (PyLong_Check(value)) {
    1062             :                         unsigned long long test_var;
    1063           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    1064           0 :                         if (PyErr_Occurred() != NULL) {
    1065           0 :                                 return -1;
    1066             :                         }
    1067           0 :                         if (test_var > uint_max) {
    1068           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    1069             :                                   PyLong_Type.tp_name, uint_max, test_var);
    1070           0 :                                 return -1;
    1071             :                         }
    1072           0 :                         object->total_sent = test_var;
    1073             :                 } else {
    1074           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1075             :                           PyLong_Type.tp_name);
    1076           0 :                         return -1;
    1077             :                 }
    1078             :         }
    1079           0 :         return 0;
    1080             : }
    1081             : 
    1082           0 : static PyObject *py_nbtd_statistics_get_query_count(PyObject *obj, void *closure)
    1083             : {
    1084           0 :         struct nbtd_statistics *object = pytalloc_get_ptr(obj);
    1085             :         PyObject *py_query_count;
    1086           0 :         py_query_count = PyLong_FromUnsignedLongLong(object->query_count);
    1087           0 :         return py_query_count;
    1088             : }
    1089             : 
    1090           0 : static int py_nbtd_statistics_set_query_count(PyObject *py_obj, PyObject *value, void *closure)
    1091             : {
    1092           0 :         struct nbtd_statistics *object = pytalloc_get_ptr(py_obj);
    1093           0 :         if (value == NULL) {
    1094           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->query_count");
    1095           0 :                 return -1;
    1096             :         }
    1097             :         {
    1098           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->query_count));
    1099           0 :                 if (PyLong_Check(value)) {
    1100             :                         unsigned long long test_var;
    1101           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    1102           0 :                         if (PyErr_Occurred() != NULL) {
    1103           0 :                                 return -1;
    1104             :                         }
    1105           0 :                         if (test_var > uint_max) {
    1106           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    1107             :                                   PyLong_Type.tp_name, uint_max, test_var);
    1108           0 :                                 return -1;
    1109             :                         }
    1110           0 :                         object->query_count = test_var;
    1111             :                 } else {
    1112           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1113             :                           PyLong_Type.tp_name);
    1114           0 :                         return -1;
    1115             :                 }
    1116             :         }
    1117           0 :         return 0;
    1118             : }
    1119             : 
    1120           0 : static PyObject *py_nbtd_statistics_get_register_count(PyObject *obj, void *closure)
    1121             : {
    1122           0 :         struct nbtd_statistics *object = pytalloc_get_ptr(obj);
    1123             :         PyObject *py_register_count;
    1124           0 :         py_register_count = PyLong_FromUnsignedLongLong(object->register_count);
    1125           0 :         return py_register_count;
    1126             : }
    1127             : 
    1128           0 : static int py_nbtd_statistics_set_register_count(PyObject *py_obj, PyObject *value, void *closure)
    1129             : {
    1130           0 :         struct nbtd_statistics *object = pytalloc_get_ptr(py_obj);
    1131           0 :         if (value == NULL) {
    1132           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->register_count");
    1133           0 :                 return -1;
    1134             :         }
    1135             :         {
    1136           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->register_count));
    1137           0 :                 if (PyLong_Check(value)) {
    1138             :                         unsigned long long test_var;
    1139           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    1140           0 :                         if (PyErr_Occurred() != NULL) {
    1141           0 :                                 return -1;
    1142             :                         }
    1143           0 :                         if (test_var > uint_max) {
    1144           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    1145             :                                   PyLong_Type.tp_name, uint_max, test_var);
    1146           0 :                                 return -1;
    1147             :                         }
    1148           0 :                         object->register_count = test_var;
    1149             :                 } else {
    1150           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1151             :                           PyLong_Type.tp_name);
    1152           0 :                         return -1;
    1153             :                 }
    1154             :         }
    1155           0 :         return 0;
    1156             : }
    1157             : 
    1158           0 : static PyObject *py_nbtd_statistics_get_release_count(PyObject *obj, void *closure)
    1159             : {
    1160           0 :         struct nbtd_statistics *object = pytalloc_get_ptr(obj);
    1161             :         PyObject *py_release_count;
    1162           0 :         py_release_count = PyLong_FromUnsignedLongLong(object->release_count);
    1163           0 :         return py_release_count;
    1164             : }
    1165             : 
    1166           0 : static int py_nbtd_statistics_set_release_count(PyObject *py_obj, PyObject *value, void *closure)
    1167             : {
    1168           0 :         struct nbtd_statistics *object = pytalloc_get_ptr(py_obj);
    1169           0 :         if (value == NULL) {
    1170           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->release_count");
    1171           0 :                 return -1;
    1172             :         }
    1173             :         {
    1174           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->release_count));
    1175           0 :                 if (PyLong_Check(value)) {
    1176             :                         unsigned long long test_var;
    1177           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    1178           0 :                         if (PyErr_Occurred() != NULL) {
    1179           0 :                                 return -1;
    1180             :                         }
    1181           0 :                         if (test_var > uint_max) {
    1182           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    1183             :                                   PyLong_Type.tp_name, uint_max, test_var);
    1184           0 :                                 return -1;
    1185             :                         }
    1186           0 :                         object->release_count = test_var;
    1187             :                 } else {
    1188           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1189             :                           PyLong_Type.tp_name);
    1190           0 :                         return -1;
    1191             :                 }
    1192             :         }
    1193           0 :         return 0;
    1194             : }
    1195             : 
    1196             : static PyGetSetDef py_nbtd_statistics_getsetters[] = {
    1197             :         {
    1198             :                 .name = discard_const_p(char, "total_received"),
    1199             :                 .get = py_nbtd_statistics_get_total_received,
    1200             :                 .set = py_nbtd_statistics_set_total_received,
    1201             :                 .doc = discard_const_p(char, "PIDL-generated element of base type hyper")
    1202             :         },
    1203             :         {
    1204             :                 .name = discard_const_p(char, "total_sent"),
    1205             :                 .get = py_nbtd_statistics_get_total_sent,
    1206             :                 .set = py_nbtd_statistics_set_total_sent,
    1207             :                 .doc = discard_const_p(char, "PIDL-generated element of base type hyper")
    1208             :         },
    1209             :         {
    1210             :                 .name = discard_const_p(char, "query_count"),
    1211             :                 .get = py_nbtd_statistics_get_query_count,
    1212             :                 .set = py_nbtd_statistics_set_query_count,
    1213             :                 .doc = discard_const_p(char, "PIDL-generated element of base type hyper")
    1214             :         },
    1215             :         {
    1216             :                 .name = discard_const_p(char, "register_count"),
    1217             :                 .get = py_nbtd_statistics_get_register_count,
    1218             :                 .set = py_nbtd_statistics_set_register_count,
    1219             :                 .doc = discard_const_p(char, "PIDL-generated element of base type hyper")
    1220             :         },
    1221             :         {
    1222             :                 .name = discard_const_p(char, "release_count"),
    1223             :                 .get = py_nbtd_statistics_get_release_count,
    1224             :                 .set = py_nbtd_statistics_set_release_count,
    1225             :                 .doc = discard_const_p(char, "PIDL-generated element of base type hyper")
    1226             :         },
    1227             :         { .name = NULL }
    1228             : };
    1229             : 
    1230           0 : static PyObject *py_nbtd_statistics_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    1231             : {
    1232           0 :         return pytalloc_new(struct nbtd_statistics, type);
    1233             : }
    1234             : 
    1235             : 
    1236             : static PyTypeObject nbtd_statistics_Type = {
    1237             :         PyVarObject_HEAD_INIT(NULL, 0)
    1238             :         .tp_name = "irpc.nbtd_statistics",
    1239             :         .tp_getset = py_nbtd_statistics_getsetters,
    1240             :         .tp_methods = NULL,
    1241             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    1242             :         .tp_new = py_nbtd_statistics_new,
    1243             : };
    1244             : 
    1245           0 : static PyObject *py_import_nbtd_info(TALLOC_CTX *mem_ctx, int level, union nbtd_info *in)
    1246             : {
    1247             :         PyObject *ret;
    1248             : 
    1249           0 :         switch (level) {
    1250           0 :                 case NBTD_INFO_STATISTICS:
    1251           0 :                         if (in->stats == NULL) {
    1252           0 :                                 ret = Py_None;
    1253           0 :                                 Py_INCREF(ret);
    1254             :                         } else {
    1255           0 :                                 ret = pytalloc_reference_ex(&nbtd_statistics_Type, in->stats, in->stats);
    1256             :                         }
    1257           0 :                         return ret;
    1258             : 
    1259             :         }
    1260           0 :         PyErr_SetString(PyExc_TypeError, "unknown union level");
    1261           0 :         return NULL;
    1262             : }
    1263             : 
    1264           0 : static union nbtd_info *py_export_nbtd_info(TALLOC_CTX *mem_ctx, int level, PyObject *in)
    1265             : {
    1266           0 :         union nbtd_info *ret = talloc_zero(mem_ctx, union nbtd_info);
    1267           0 :         switch (level) {
    1268           0 :                 case NBTD_INFO_STATISTICS:
    1269           0 :                         if (in == NULL) {
    1270           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->stats");
    1271           0 :                                 talloc_free(ret); return NULL;
    1272             :                         }
    1273           0 :                         if (in == Py_None) {
    1274           0 :                                 ret->stats = NULL;
    1275             :                         } else {
    1276           0 :                                 ret->stats = NULL;
    1277           0 :                                 PY_CHECK_TYPE(&nbtd_statistics_Type, in, talloc_free(ret); return NULL;);
    1278           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1279           0 :                                         PyErr_NoMemory();
    1280           0 :                                         talloc_free(ret); return NULL;
    1281             :                                 }
    1282           0 :                                 ret->stats = (struct nbtd_statistics *)pytalloc_get_ptr(in);
    1283             :                         }
    1284           0 :                         break;
    1285             : 
    1286           0 :                 default:
    1287           0 :                         PyErr_SetString(PyExc_TypeError, "invalid union level value");
    1288           0 :                         talloc_free(ret);
    1289           0 :                         ret = NULL;
    1290             :         }
    1291             : 
    1292           0 :         return ret;
    1293             : }
    1294             : 
    1295           0 : static PyObject *py_nbtd_info_import(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    1296             : {
    1297           0 :         const char * const kwnames[] = { "mem_ctx", "level", "in", NULL };
    1298           0 :         PyObject *mem_ctx_obj = NULL;
    1299           0 :         TALLOC_CTX *mem_ctx = NULL;
    1300           0 :         int level = 0;
    1301           0 :         PyObject *in_obj = NULL;
    1302           0 :         union nbtd_info *in = NULL;
    1303             : 
    1304           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OiO:import",
    1305             :                 discard_const_p(char *, kwnames),
    1306             :                 &mem_ctx_obj,
    1307             :                 &level,
    1308             :                 &in_obj)) {
    1309           0 :                 return NULL;
    1310             :         }
    1311           0 :         mem_ctx = pytalloc_get_ptr(mem_ctx_obj);
    1312           0 :         if (mem_ctx == NULL) {
    1313           0 :                 PyErr_SetString(PyExc_TypeError, "mem_ctx is NULL)!");
    1314           0 :                 return NULL;
    1315             :         }
    1316           0 :         in = (union nbtd_info *)pytalloc_get_ptr(in_obj);
    1317           0 :         if (in == NULL) {
    1318           0 :                 PyErr_Format(PyExc_TypeError, "in needs to be a pointer to union nbtd_info!");
    1319           0 :                 return NULL;
    1320             :         }
    1321             : 
    1322           0 :         return py_import_nbtd_info(mem_ctx, level, in);
    1323             : }
    1324             : 
    1325           0 : static PyObject *py_nbtd_info_export(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    1326             : {
    1327           0 :         const char * const kwnames[] = { "mem_ctx", "level", "in", NULL };
    1328           0 :         PyObject *mem_ctx_obj = NULL;
    1329           0 :         TALLOC_CTX *mem_ctx = NULL;
    1330           0 :         int level = 0;
    1331           0 :         PyObject *in = NULL;
    1332           0 :         union nbtd_info *out = NULL;
    1333             : 
    1334           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OiO:export",
    1335             :                 discard_const_p(char *, kwnames),
    1336             :                 &mem_ctx_obj,
    1337             :                 &level,
    1338             :                 &in)) {
    1339           0 :                 return NULL;
    1340             :         }
    1341           0 :         mem_ctx = pytalloc_get_ptr(mem_ctx_obj);
    1342           0 :         if (mem_ctx == NULL) {
    1343           0 :                 PyErr_SetString(PyExc_TypeError, "mem_ctx is NULL)!");
    1344           0 :                 return NULL;
    1345             :         }
    1346             : 
    1347           0 :         out = py_export_nbtd_info(mem_ctx, level, in);
    1348           0 :         if (out == NULL) {
    1349           0 :                 return NULL;
    1350             :         }
    1351             : 
    1352           0 :         return pytalloc_GenericObject_reference(out);
    1353             : }
    1354             : 
    1355             : static PyMethodDef py_nbtd_info_methods[] = {
    1356             :         { "__import__", PY_DISCARD_FUNC_SIG(PyCFunction,py_nbtd_info_import),
    1357             :                 METH_VARARGS|METH_KEYWORDS|METH_CLASS,
    1358             :                 "T.__import__(mem_ctx, level, in) => ret." },
    1359             :         { "__export__", PY_DISCARD_FUNC_SIG(PyCFunction,py_nbtd_info_export),
    1360             :                 METH_VARARGS|METH_KEYWORDS|METH_CLASS,
    1361             :                 "T.__export__(mem_ctx, level, in) => ret." },
    1362             :         { NULL, NULL, 0, NULL }
    1363             : };
    1364             : 
    1365           0 : static PyObject *py_nbtd_info_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    1366             : {
    1367           0 :         PyErr_Format(PyExc_TypeError, "New %s Objects are not supported", type->tp_name);
    1368           0 :         return NULL;
    1369             : }
    1370             : 
    1371             : 
    1372             : static PyTypeObject nbtd_info_Type = {
    1373             :         PyVarObject_HEAD_INIT(NULL, 0)
    1374             :         .tp_name = "irpc.nbtd_info",
    1375             :         .tp_getset = NULL,
    1376             :         .tp_methods = py_nbtd_info_methods,
    1377             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    1378             :         .tp_new = py_nbtd_info_new,
    1379             : };
    1380             : 
    1381             : 
    1382           0 : static PyObject *py_nbtd_proxy_wins_addr_get_addr(PyObject *obj, void *closure)
    1383             : {
    1384           0 :         struct nbtd_proxy_wins_addr *object = pytalloc_get_ptr(obj);
    1385             :         PyObject *py_addr;
    1386           0 :         py_addr = PyString_FromStringOrNULL(object->addr);
    1387           0 :         return py_addr;
    1388             : }
    1389             : 
    1390           0 : static int py_nbtd_proxy_wins_addr_set_addr(PyObject *py_obj, PyObject *value, void *closure)
    1391             : {
    1392           0 :         struct nbtd_proxy_wins_addr *object = pytalloc_get_ptr(py_obj);
    1393           0 :         if (value == NULL) {
    1394           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->addr");
    1395           0 :                 return -1;
    1396             :         }
    1397             :         {
    1398             :                 const char *test_str;
    1399             :                 const char *talloc_str;
    1400           0 :                 PyObject *unicode = NULL;
    1401           0 :                 if (PyUnicode_Check(value)) {
    1402           0 :                         unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    1403           0 :                         if (unicode == NULL) {
    1404           0 :                                 return -1;
    1405             :                         }
    1406           0 :                         test_str = PyBytes_AS_STRING(unicode);
    1407           0 :                 } else if (PyBytes_Check(value)) {
    1408           0 :                         test_str = PyBytes_AS_STRING(value);
    1409             :                 } else {
    1410           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    1411           0 :                         return -1;
    1412             :                 }
    1413           0 :                 talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    1414           0 :                 if (unicode != NULL) {
    1415           0 :                         Py_DECREF(unicode);
    1416             :                 }
    1417           0 :                 if (talloc_str == NULL) {
    1418           0 :                         PyErr_NoMemory();
    1419           0 :                         return -1;
    1420             :                 }
    1421           0 :                 object->addr = talloc_str;
    1422             :         }
    1423           0 :         return 0;
    1424             : }
    1425             : 
    1426             : static PyGetSetDef py_nbtd_proxy_wins_addr_getsetters[] = {
    1427             :         {
    1428             :                 .name = discard_const_p(char, "addr"),
    1429             :                 .get = py_nbtd_proxy_wins_addr_get_addr,
    1430             :                 .set = py_nbtd_proxy_wins_addr_set_addr,
    1431             :                 .doc = discard_const_p(char, "PIDL-generated element of base type ipv4address")
    1432             :         },
    1433             :         { .name = NULL }
    1434             : };
    1435             : 
    1436           0 : static PyObject *py_nbtd_proxy_wins_addr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    1437             : {
    1438           0 :         return pytalloc_new(struct nbtd_proxy_wins_addr, type);
    1439             : }
    1440             : 
    1441             : 
    1442             : static PyTypeObject nbtd_proxy_wins_addr_Type = {
    1443             :         PyVarObject_HEAD_INIT(NULL, 0)
    1444             :         .tp_name = "irpc.nbtd_proxy_wins_addr",
    1445             :         .tp_getset = py_nbtd_proxy_wins_addr_getsetters,
    1446             :         .tp_methods = NULL,
    1447             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    1448             :         .tp_new = py_nbtd_proxy_wins_addr_new,
    1449             : };
    1450             : 
    1451             : 
    1452           0 : static PyObject *py_smbsrv_session_info_get_vuid(PyObject *obj, void *closure)
    1453             : {
    1454           0 :         struct smbsrv_session_info *object = pytalloc_get_ptr(obj);
    1455             :         PyObject *py_vuid;
    1456           0 :         py_vuid = PyLong_FromUnsignedLongLong(object->vuid);
    1457           0 :         return py_vuid;
    1458             : }
    1459             : 
    1460           0 : static int py_smbsrv_session_info_set_vuid(PyObject *py_obj, PyObject *value, void *closure)
    1461             : {
    1462           0 :         struct smbsrv_session_info *object = pytalloc_get_ptr(py_obj);
    1463           0 :         if (value == NULL) {
    1464           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->vuid");
    1465           0 :                 return -1;
    1466             :         }
    1467             :         {
    1468           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->vuid));
    1469           0 :                 if (PyLong_Check(value)) {
    1470             :                         unsigned long long test_var;
    1471           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    1472           0 :                         if (PyErr_Occurred() != NULL) {
    1473           0 :                                 return -1;
    1474             :                         }
    1475           0 :                         if (test_var > uint_max) {
    1476           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    1477             :                                   PyLong_Type.tp_name, uint_max, test_var);
    1478           0 :                                 return -1;
    1479             :                         }
    1480           0 :                         object->vuid = test_var;
    1481             :                 } else {
    1482           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1483             :                           PyLong_Type.tp_name);
    1484           0 :                         return -1;
    1485             :                 }
    1486             :         }
    1487           0 :         return 0;
    1488             : }
    1489             : 
    1490           0 : static PyObject *py_smbsrv_session_info_get_account_name(PyObject *obj, void *closure)
    1491             : {
    1492           0 :         struct smbsrv_session_info *object = pytalloc_get_ptr(obj);
    1493             :         PyObject *py_account_name;
    1494           0 :         py_account_name = PyString_FromStringOrNULL(object->account_name);
    1495           0 :         return py_account_name;
    1496             : }
    1497             : 
    1498           0 : static int py_smbsrv_session_info_set_account_name(PyObject *py_obj, PyObject *value, void *closure)
    1499             : {
    1500           0 :         struct smbsrv_session_info *object = pytalloc_get_ptr(py_obj);
    1501           0 :         if (value == NULL) {
    1502           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->account_name");
    1503           0 :                 return -1;
    1504             :         }
    1505             :         {
    1506             :                 const char *test_str;
    1507             :                 const char *talloc_str;
    1508           0 :                 PyObject *unicode = NULL;
    1509           0 :                 if (PyUnicode_Check(value)) {
    1510           0 :                         unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    1511           0 :                         if (unicode == NULL) {
    1512           0 :                                 return -1;
    1513             :                         }
    1514           0 :                         test_str = PyBytes_AS_STRING(unicode);
    1515           0 :                 } else if (PyBytes_Check(value)) {
    1516           0 :                         test_str = PyBytes_AS_STRING(value);
    1517             :                 } else {
    1518           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    1519           0 :                         return -1;
    1520             :                 }
    1521           0 :                 talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    1522           0 :                 if (unicode != NULL) {
    1523           0 :                         Py_DECREF(unicode);
    1524             :                 }
    1525           0 :                 if (talloc_str == NULL) {
    1526           0 :                         PyErr_NoMemory();
    1527           0 :                         return -1;
    1528             :                 }
    1529           0 :                 object->account_name = talloc_str;
    1530             :         }
    1531           0 :         return 0;
    1532             : }
    1533             : 
    1534           0 : static PyObject *py_smbsrv_session_info_get_domain_name(PyObject *obj, void *closure)
    1535             : {
    1536           0 :         struct smbsrv_session_info *object = pytalloc_get_ptr(obj);
    1537             :         PyObject *py_domain_name;
    1538           0 :         py_domain_name = PyString_FromStringOrNULL(object->domain_name);
    1539           0 :         return py_domain_name;
    1540             : }
    1541             : 
    1542           0 : static int py_smbsrv_session_info_set_domain_name(PyObject *py_obj, PyObject *value, void *closure)
    1543             : {
    1544           0 :         struct smbsrv_session_info *object = pytalloc_get_ptr(py_obj);
    1545           0 :         if (value == NULL) {
    1546           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->domain_name");
    1547           0 :                 return -1;
    1548             :         }
    1549             :         {
    1550             :                 const char *test_str;
    1551             :                 const char *talloc_str;
    1552           0 :                 PyObject *unicode = NULL;
    1553           0 :                 if (PyUnicode_Check(value)) {
    1554           0 :                         unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    1555           0 :                         if (unicode == NULL) {
    1556           0 :                                 return -1;
    1557             :                         }
    1558           0 :                         test_str = PyBytes_AS_STRING(unicode);
    1559           0 :                 } else if (PyBytes_Check(value)) {
    1560           0 :                         test_str = PyBytes_AS_STRING(value);
    1561             :                 } else {
    1562           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    1563           0 :                         return -1;
    1564             :                 }
    1565           0 :                 talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    1566           0 :                 if (unicode != NULL) {
    1567           0 :                         Py_DECREF(unicode);
    1568             :                 }
    1569           0 :                 if (talloc_str == NULL) {
    1570           0 :                         PyErr_NoMemory();
    1571           0 :                         return -1;
    1572             :                 }
    1573           0 :                 object->domain_name = talloc_str;
    1574             :         }
    1575           0 :         return 0;
    1576             : }
    1577             : 
    1578           0 : static PyObject *py_smbsrv_session_info_get_client_ip(PyObject *obj, void *closure)
    1579             : {
    1580           0 :         struct smbsrv_session_info *object = pytalloc_get_ptr(obj);
    1581             :         PyObject *py_client_ip;
    1582           0 :         py_client_ip = PyString_FromStringOrNULL(object->client_ip);
    1583           0 :         return py_client_ip;
    1584             : }
    1585             : 
    1586           0 : static int py_smbsrv_session_info_set_client_ip(PyObject *py_obj, PyObject *value, void *closure)
    1587             : {
    1588           0 :         struct smbsrv_session_info *object = pytalloc_get_ptr(py_obj);
    1589           0 :         if (value == NULL) {
    1590           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->client_ip");
    1591           0 :                 return -1;
    1592             :         }
    1593             :         {
    1594             :                 const char *test_str;
    1595             :                 const char *talloc_str;
    1596           0 :                 PyObject *unicode = NULL;
    1597           0 :                 if (PyUnicode_Check(value)) {
    1598           0 :                         unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    1599           0 :                         if (unicode == NULL) {
    1600           0 :                                 return -1;
    1601             :                         }
    1602           0 :                         test_str = PyBytes_AS_STRING(unicode);
    1603           0 :                 } else if (PyBytes_Check(value)) {
    1604           0 :                         test_str = PyBytes_AS_STRING(value);
    1605             :                 } else {
    1606           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    1607           0 :                         return -1;
    1608             :                 }
    1609           0 :                 talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    1610           0 :                 if (unicode != NULL) {
    1611           0 :                         Py_DECREF(unicode);
    1612             :                 }
    1613           0 :                 if (talloc_str == NULL) {
    1614           0 :                         PyErr_NoMemory();
    1615           0 :                         return -1;
    1616             :                 }
    1617           0 :                 object->client_ip = talloc_str;
    1618             :         }
    1619           0 :         return 0;
    1620             : }
    1621             : 
    1622           0 : static PyObject *py_smbsrv_session_info_get_connect_time(PyObject *obj, void *closure)
    1623             : {
    1624           0 :         struct smbsrv_session_info *object = pytalloc_get_ptr(obj);
    1625             :         PyObject *py_connect_time;
    1626           0 :         py_connect_time = PyLong_FromUnsignedLongLong(object->connect_time);
    1627           0 :         return py_connect_time;
    1628             : }
    1629             : 
    1630           0 : static int py_smbsrv_session_info_set_connect_time(PyObject *py_obj, PyObject *value, void *closure)
    1631             : {
    1632           0 :         struct smbsrv_session_info *object = pytalloc_get_ptr(py_obj);
    1633           0 :         if (value == NULL) {
    1634           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->connect_time");
    1635           0 :                 return -1;
    1636             :         }
    1637             :         {
    1638           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->connect_time));
    1639           0 :                 if (PyLong_Check(value)) {
    1640             :                         unsigned long long test_var;
    1641           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    1642           0 :                         if (PyErr_Occurred() != NULL) {
    1643           0 :                                 return -1;
    1644             :                         }
    1645           0 :                         if (test_var > uint_max) {
    1646           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    1647             :                                   PyLong_Type.tp_name, uint_max, test_var);
    1648           0 :                                 return -1;
    1649             :                         }
    1650           0 :                         object->connect_time = test_var;
    1651             :                 } else {
    1652           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1653             :                           PyLong_Type.tp_name);
    1654           0 :                         return -1;
    1655             :                 }
    1656             :         }
    1657           0 :         return 0;
    1658             : }
    1659             : 
    1660           0 : static PyObject *py_smbsrv_session_info_get_auth_time(PyObject *obj, void *closure)
    1661             : {
    1662           0 :         struct smbsrv_session_info *object = pytalloc_get_ptr(obj);
    1663             :         PyObject *py_auth_time;
    1664           0 :         py_auth_time = PyLong_FromUnsignedLongLong(object->auth_time);
    1665           0 :         return py_auth_time;
    1666             : }
    1667             : 
    1668           0 : static int py_smbsrv_session_info_set_auth_time(PyObject *py_obj, PyObject *value, void *closure)
    1669             : {
    1670           0 :         struct smbsrv_session_info *object = pytalloc_get_ptr(py_obj);
    1671           0 :         if (value == NULL) {
    1672           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->auth_time");
    1673           0 :                 return -1;
    1674             :         }
    1675             :         {
    1676           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->auth_time));
    1677           0 :                 if (PyLong_Check(value)) {
    1678             :                         unsigned long long test_var;
    1679           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    1680           0 :                         if (PyErr_Occurred() != NULL) {
    1681           0 :                                 return -1;
    1682             :                         }
    1683           0 :                         if (test_var > uint_max) {
    1684           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    1685             :                                   PyLong_Type.tp_name, uint_max, test_var);
    1686           0 :                                 return -1;
    1687             :                         }
    1688           0 :                         object->auth_time = test_var;
    1689             :                 } else {
    1690           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1691             :                           PyLong_Type.tp_name);
    1692           0 :                         return -1;
    1693             :                 }
    1694             :         }
    1695           0 :         return 0;
    1696             : }
    1697             : 
    1698           0 : static PyObject *py_smbsrv_session_info_get_last_use_time(PyObject *obj, void *closure)
    1699             : {
    1700           0 :         struct smbsrv_session_info *object = pytalloc_get_ptr(obj);
    1701             :         PyObject *py_last_use_time;
    1702           0 :         py_last_use_time = PyLong_FromUnsignedLongLong(object->last_use_time);
    1703           0 :         return py_last_use_time;
    1704             : }
    1705             : 
    1706           0 : static int py_smbsrv_session_info_set_last_use_time(PyObject *py_obj, PyObject *value, void *closure)
    1707             : {
    1708           0 :         struct smbsrv_session_info *object = pytalloc_get_ptr(py_obj);
    1709           0 :         if (value == NULL) {
    1710           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->last_use_time");
    1711           0 :                 return -1;
    1712             :         }
    1713             :         {
    1714           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->last_use_time));
    1715           0 :                 if (PyLong_Check(value)) {
    1716             :                         unsigned long long test_var;
    1717           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    1718           0 :                         if (PyErr_Occurred() != NULL) {
    1719           0 :                                 return -1;
    1720             :                         }
    1721           0 :                         if (test_var > uint_max) {
    1722           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    1723             :                                   PyLong_Type.tp_name, uint_max, test_var);
    1724           0 :                                 return -1;
    1725             :                         }
    1726           0 :                         object->last_use_time = test_var;
    1727             :                 } else {
    1728           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1729             :                           PyLong_Type.tp_name);
    1730           0 :                         return -1;
    1731             :                 }
    1732             :         }
    1733           0 :         return 0;
    1734             : }
    1735             : 
    1736             : static PyGetSetDef py_smbsrv_session_info_getsetters[] = {
    1737             :         {
    1738             :                 .name = discard_const_p(char, "vuid"),
    1739             :                 .get = py_smbsrv_session_info_get_vuid,
    1740             :                 .set = py_smbsrv_session_info_set_vuid,
    1741             :                 .doc = discard_const_p(char, "PIDL-generated element of base type hyper")
    1742             :         },
    1743             :         {
    1744             :                 .name = discard_const_p(char, "account_name"),
    1745             :                 .get = py_smbsrv_session_info_get_account_name,
    1746             :                 .set = py_smbsrv_session_info_set_account_name,
    1747             :                 .doc = discard_const_p(char, "PIDL-generated element of base type string")
    1748             :         },
    1749             :         {
    1750             :                 .name = discard_const_p(char, "domain_name"),
    1751             :                 .get = py_smbsrv_session_info_get_domain_name,
    1752             :                 .set = py_smbsrv_session_info_set_domain_name,
    1753             :                 .doc = discard_const_p(char, "PIDL-generated element of base type string")
    1754             :         },
    1755             :         {
    1756             :                 .name = discard_const_p(char, "client_ip"),
    1757             :                 .get = py_smbsrv_session_info_get_client_ip,
    1758             :                 .set = py_smbsrv_session_info_set_client_ip,
    1759             :                 .doc = discard_const_p(char, "PIDL-generated element of base type string")
    1760             :         },
    1761             :         {
    1762             :                 .name = discard_const_p(char, "connect_time"),
    1763             :                 .get = py_smbsrv_session_info_get_connect_time,
    1764             :                 .set = py_smbsrv_session_info_set_connect_time,
    1765             :                 .doc = discard_const_p(char, "PIDL-generated element of base type NTTIME")
    1766             :         },
    1767             :         {
    1768             :                 .name = discard_const_p(char, "auth_time"),
    1769             :                 .get = py_smbsrv_session_info_get_auth_time,
    1770             :                 .set = py_smbsrv_session_info_set_auth_time,
    1771             :                 .doc = discard_const_p(char, "PIDL-generated element of base type NTTIME")
    1772             :         },
    1773             :         {
    1774             :                 .name = discard_const_p(char, "last_use_time"),
    1775             :                 .get = py_smbsrv_session_info_get_last_use_time,
    1776             :                 .set = py_smbsrv_session_info_set_last_use_time,
    1777             :                 .doc = discard_const_p(char, "PIDL-generated element of base type NTTIME")
    1778             :         },
    1779             :         { .name = NULL }
    1780             : };
    1781             : 
    1782           0 : static PyObject *py_smbsrv_session_info_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    1783             : {
    1784           0 :         return pytalloc_new(struct smbsrv_session_info, type);
    1785             : }
    1786             : 
    1787             : 
    1788             : static PyTypeObject smbsrv_session_info_Type = {
    1789             :         PyVarObject_HEAD_INIT(NULL, 0)
    1790             :         .tp_name = "irpc.smbsrv_session_info",
    1791             :         .tp_getset = py_smbsrv_session_info_getsetters,
    1792             :         .tp_methods = NULL,
    1793             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    1794             :         .tp_new = py_smbsrv_session_info_new,
    1795             : };
    1796             : 
    1797             : 
    1798           0 : static PyObject *py_smbsrv_sessions_get_num_sessions(PyObject *obj, void *closure)
    1799             : {
    1800           0 :         struct smbsrv_sessions *object = pytalloc_get_ptr(obj);
    1801             :         PyObject *py_num_sessions;
    1802           0 :         py_num_sessions = PyLong_FromUnsignedLongLong((uint32_t)(object->num_sessions));
    1803           0 :         return py_num_sessions;
    1804             : }
    1805             : 
    1806           0 : static int py_smbsrv_sessions_set_num_sessions(PyObject *py_obj, PyObject *value, void *closure)
    1807             : {
    1808           0 :         struct smbsrv_sessions *object = pytalloc_get_ptr(py_obj);
    1809           0 :         if (value == NULL) {
    1810           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->num_sessions");
    1811           0 :                 return -1;
    1812             :         }
    1813             :         {
    1814           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->num_sessions));
    1815           0 :                 if (PyLong_Check(value)) {
    1816             :                         unsigned long long test_var;
    1817           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    1818           0 :                         if (PyErr_Occurred() != NULL) {
    1819           0 :                                 return -1;
    1820             :                         }
    1821           0 :                         if (test_var > uint_max) {
    1822           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    1823             :                                   PyLong_Type.tp_name, uint_max, test_var);
    1824           0 :                                 return -1;
    1825             :                         }
    1826           0 :                         object->num_sessions = test_var;
    1827             :                 } else {
    1828           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1829             :                           PyLong_Type.tp_name);
    1830           0 :                         return -1;
    1831             :                 }
    1832             :         }
    1833           0 :         return 0;
    1834             : }
    1835             : 
    1836           0 : static PyObject *py_smbsrv_sessions_get_sessions(PyObject *obj, void *closure)
    1837             : {
    1838           0 :         struct smbsrv_sessions *object = pytalloc_get_ptr(obj);
    1839             :         PyObject *py_sessions;
    1840           0 :         if (object->sessions == NULL) {
    1841           0 :                 Py_RETURN_NONE;
    1842             :         }
    1843           0 :         if (object->sessions == NULL) {
    1844           0 :                 py_sessions = Py_None;
    1845           0 :                 Py_INCREF(py_sessions);
    1846             :         } else {
    1847           0 :                 py_sessions = PyList_New(object->num_sessions);
    1848           0 :                 if (py_sessions == NULL) {
    1849           0 :                         return NULL;
    1850             :                 }
    1851             :                 {
    1852             :                         int sessions_cntr_1;
    1853           0 :                         for (sessions_cntr_1 = 0; sessions_cntr_1 < (object->num_sessions); sessions_cntr_1++) {
    1854             :                                 PyObject *py_sessions_1;
    1855           0 :                                 py_sessions_1 = pytalloc_reference_ex(&smbsrv_session_info_Type, object->sessions, &(object->sessions)[sessions_cntr_1]);
    1856           0 :                                 PyList_SetItem(py_sessions, sessions_cntr_1, py_sessions_1);
    1857             :                         }
    1858             :                 }
    1859             :         }
    1860           0 :         return py_sessions;
    1861             : }
    1862             : 
    1863           0 : static int py_smbsrv_sessions_set_sessions(PyObject *py_obj, PyObject *value, void *closure)
    1864             : {
    1865           0 :         struct smbsrv_sessions *object = pytalloc_get_ptr(py_obj);
    1866           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->sessions));
    1867           0 :         if (value == NULL) {
    1868           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->sessions");
    1869           0 :                 return -1;
    1870             :         }
    1871           0 :         if (value == Py_None) {
    1872           0 :                 object->sessions = NULL;
    1873             :         } else {
    1874           0 :                 object->sessions = NULL;
    1875           0 :                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
    1876             :                 {
    1877             :                         int sessions_cntr_1;
    1878           0 :                         object->sessions = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->sessions, PyList_GET_SIZE(value));
    1879           0 :                         if (!object->sessions) { return -1; }
    1880           0 :                         talloc_set_name_const(object->sessions, "ARRAY: object->sessions");
    1881           0 :                         for (sessions_cntr_1 = 0; sessions_cntr_1 < PyList_GET_SIZE(value); sessions_cntr_1++) {
    1882           0 :                                 if (PyList_GET_ITEM(value, sessions_cntr_1) == NULL) {
    1883           0 :                                         PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->sessions)[sessions_cntr_1]");
    1884           0 :                                         return -1;
    1885             :                                 }
    1886           0 :                                 PY_CHECK_TYPE(&smbsrv_session_info_Type, PyList_GET_ITEM(value, sessions_cntr_1), return -1;);
    1887           0 :                                 if (talloc_reference(object->sessions, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, sessions_cntr_1))) == NULL) {
    1888           0 :                                         PyErr_NoMemory();
    1889           0 :                                         return -1;
    1890             :                                 }
    1891           0 :                                 (object->sessions)[sessions_cntr_1] = *(struct smbsrv_session_info *)pytalloc_get_ptr(PyList_GET_ITEM(value, sessions_cntr_1));
    1892             :                         }
    1893             :                 }
    1894             :         }
    1895           0 :         return 0;
    1896             : }
    1897             : 
    1898             : static PyGetSetDef py_smbsrv_sessions_getsetters[] = {
    1899             :         {
    1900             :                 .name = discard_const_p(char, "num_sessions"),
    1901             :                 .get = py_smbsrv_sessions_get_num_sessions,
    1902             :                 .set = py_smbsrv_sessions_set_num_sessions,
    1903             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    1904             :         },
    1905             :         {
    1906             :                 .name = discard_const_p(char, "sessions"),
    1907             :                 .get = py_smbsrv_sessions_get_sessions,
    1908             :                 .set = py_smbsrv_sessions_set_sessions,
    1909             :                 .doc = discard_const_p(char, "PIDL-generated element of base type smbsrv_session_info")
    1910             :         },
    1911             :         { .name = NULL }
    1912             : };
    1913             : 
    1914           0 : static PyObject *py_smbsrv_sessions_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    1915             : {
    1916           0 :         return pytalloc_new(struct smbsrv_sessions, type);
    1917             : }
    1918             : 
    1919             : 
    1920             : static PyTypeObject smbsrv_sessions_Type = {
    1921             :         PyVarObject_HEAD_INIT(NULL, 0)
    1922             :         .tp_name = "irpc.smbsrv_sessions",
    1923             :         .tp_getset = py_smbsrv_sessions_getsetters,
    1924             :         .tp_methods = NULL,
    1925             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    1926             :         .tp_new = py_smbsrv_sessions_new,
    1927             : };
    1928             : 
    1929             : 
    1930           0 : static PyObject *py_smbsrv_tcon_info_get_tid(PyObject *obj, void *closure)
    1931             : {
    1932           0 :         struct smbsrv_tcon_info *object = pytalloc_get_ptr(obj);
    1933             :         PyObject *py_tid;
    1934           0 :         py_tid = PyLong_FromUnsignedLongLong((uint32_t)(object->tid));
    1935           0 :         return py_tid;
    1936             : }
    1937             : 
    1938           0 : static int py_smbsrv_tcon_info_set_tid(PyObject *py_obj, PyObject *value, void *closure)
    1939             : {
    1940           0 :         struct smbsrv_tcon_info *object = pytalloc_get_ptr(py_obj);
    1941           0 :         if (value == NULL) {
    1942           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->tid");
    1943           0 :                 return -1;
    1944             :         }
    1945             :         {
    1946           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->tid));
    1947           0 :                 if (PyLong_Check(value)) {
    1948             :                         unsigned long long test_var;
    1949           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    1950           0 :                         if (PyErr_Occurred() != NULL) {
    1951           0 :                                 return -1;
    1952             :                         }
    1953           0 :                         if (test_var > uint_max) {
    1954           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    1955             :                                   PyLong_Type.tp_name, uint_max, test_var);
    1956           0 :                                 return -1;
    1957             :                         }
    1958           0 :                         object->tid = test_var;
    1959             :                 } else {
    1960           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1961             :                           PyLong_Type.tp_name);
    1962           0 :                         return -1;
    1963             :                 }
    1964             :         }
    1965           0 :         return 0;
    1966             : }
    1967             : 
    1968           0 : static PyObject *py_smbsrv_tcon_info_get_share_name(PyObject *obj, void *closure)
    1969             : {
    1970           0 :         struct smbsrv_tcon_info *object = pytalloc_get_ptr(obj);
    1971             :         PyObject *py_share_name;
    1972           0 :         py_share_name = PyString_FromStringOrNULL(object->share_name);
    1973           0 :         return py_share_name;
    1974             : }
    1975             : 
    1976           0 : static int py_smbsrv_tcon_info_set_share_name(PyObject *py_obj, PyObject *value, void *closure)
    1977             : {
    1978           0 :         struct smbsrv_tcon_info *object = pytalloc_get_ptr(py_obj);
    1979           0 :         if (value == NULL) {
    1980           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->share_name");
    1981           0 :                 return -1;
    1982             :         }
    1983             :         {
    1984             :                 const char *test_str;
    1985             :                 const char *talloc_str;
    1986           0 :                 PyObject *unicode = NULL;
    1987           0 :                 if (PyUnicode_Check(value)) {
    1988           0 :                         unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    1989           0 :                         if (unicode == NULL) {
    1990           0 :                                 return -1;
    1991             :                         }
    1992           0 :                         test_str = PyBytes_AS_STRING(unicode);
    1993           0 :                 } else if (PyBytes_Check(value)) {
    1994           0 :                         test_str = PyBytes_AS_STRING(value);
    1995             :                 } else {
    1996           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    1997           0 :                         return -1;
    1998             :                 }
    1999           0 :                 talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    2000           0 :                 if (unicode != NULL) {
    2001           0 :                         Py_DECREF(unicode);
    2002             :                 }
    2003           0 :                 if (talloc_str == NULL) {
    2004           0 :                         PyErr_NoMemory();
    2005           0 :                         return -1;
    2006             :                 }
    2007           0 :                 object->share_name = talloc_str;
    2008             :         }
    2009           0 :         return 0;
    2010             : }
    2011             : 
    2012           0 : static PyObject *py_smbsrv_tcon_info_get_client_ip(PyObject *obj, void *closure)
    2013             : {
    2014           0 :         struct smbsrv_tcon_info *object = pytalloc_get_ptr(obj);
    2015             :         PyObject *py_client_ip;
    2016           0 :         py_client_ip = PyString_FromStringOrNULL(object->client_ip);
    2017           0 :         return py_client_ip;
    2018             : }
    2019             : 
    2020           0 : static int py_smbsrv_tcon_info_set_client_ip(PyObject *py_obj, PyObject *value, void *closure)
    2021             : {
    2022           0 :         struct smbsrv_tcon_info *object = pytalloc_get_ptr(py_obj);
    2023           0 :         if (value == NULL) {
    2024           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->client_ip");
    2025           0 :                 return -1;
    2026             :         }
    2027             :         {
    2028             :                 const char *test_str;
    2029             :                 const char *talloc_str;
    2030           0 :                 PyObject *unicode = NULL;
    2031           0 :                 if (PyUnicode_Check(value)) {
    2032           0 :                         unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    2033           0 :                         if (unicode == NULL) {
    2034           0 :                                 return -1;
    2035             :                         }
    2036           0 :                         test_str = PyBytes_AS_STRING(unicode);
    2037           0 :                 } else if (PyBytes_Check(value)) {
    2038           0 :                         test_str = PyBytes_AS_STRING(value);
    2039             :                 } else {
    2040           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    2041           0 :                         return -1;
    2042             :                 }
    2043           0 :                 talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    2044           0 :                 if (unicode != NULL) {
    2045           0 :                         Py_DECREF(unicode);
    2046             :                 }
    2047           0 :                 if (talloc_str == NULL) {
    2048           0 :                         PyErr_NoMemory();
    2049           0 :                         return -1;
    2050             :                 }
    2051           0 :                 object->client_ip = talloc_str;
    2052             :         }
    2053           0 :         return 0;
    2054             : }
    2055             : 
    2056           0 : static PyObject *py_smbsrv_tcon_info_get_connect_time(PyObject *obj, void *closure)
    2057             : {
    2058           0 :         struct smbsrv_tcon_info *object = pytalloc_get_ptr(obj);
    2059             :         PyObject *py_connect_time;
    2060           0 :         py_connect_time = PyLong_FromUnsignedLongLong(object->connect_time);
    2061           0 :         return py_connect_time;
    2062             : }
    2063             : 
    2064           0 : static int py_smbsrv_tcon_info_set_connect_time(PyObject *py_obj, PyObject *value, void *closure)
    2065             : {
    2066           0 :         struct smbsrv_tcon_info *object = pytalloc_get_ptr(py_obj);
    2067           0 :         if (value == NULL) {
    2068           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->connect_time");
    2069           0 :                 return -1;
    2070             :         }
    2071             :         {
    2072           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->connect_time));
    2073           0 :                 if (PyLong_Check(value)) {
    2074             :                         unsigned long long test_var;
    2075           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    2076           0 :                         if (PyErr_Occurred() != NULL) {
    2077           0 :                                 return -1;
    2078             :                         }
    2079           0 :                         if (test_var > uint_max) {
    2080           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2081             :                                   PyLong_Type.tp_name, uint_max, test_var);
    2082           0 :                                 return -1;
    2083             :                         }
    2084           0 :                         object->connect_time = test_var;
    2085             :                 } else {
    2086           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2087             :                           PyLong_Type.tp_name);
    2088           0 :                         return -1;
    2089             :                 }
    2090             :         }
    2091           0 :         return 0;
    2092             : }
    2093             : 
    2094           0 : static PyObject *py_smbsrv_tcon_info_get_last_use_time(PyObject *obj, void *closure)
    2095             : {
    2096           0 :         struct smbsrv_tcon_info *object = pytalloc_get_ptr(obj);
    2097             :         PyObject *py_last_use_time;
    2098           0 :         py_last_use_time = PyLong_FromUnsignedLongLong(object->last_use_time);
    2099           0 :         return py_last_use_time;
    2100             : }
    2101             : 
    2102           0 : static int py_smbsrv_tcon_info_set_last_use_time(PyObject *py_obj, PyObject *value, void *closure)
    2103             : {
    2104           0 :         struct smbsrv_tcon_info *object = pytalloc_get_ptr(py_obj);
    2105           0 :         if (value == NULL) {
    2106           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->last_use_time");
    2107           0 :                 return -1;
    2108             :         }
    2109             :         {
    2110           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->last_use_time));
    2111           0 :                 if (PyLong_Check(value)) {
    2112             :                         unsigned long long test_var;
    2113           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    2114           0 :                         if (PyErr_Occurred() != NULL) {
    2115           0 :                                 return -1;
    2116             :                         }
    2117           0 :                         if (test_var > uint_max) {
    2118           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2119             :                                   PyLong_Type.tp_name, uint_max, test_var);
    2120           0 :                                 return -1;
    2121             :                         }
    2122           0 :                         object->last_use_time = test_var;
    2123             :                 } else {
    2124           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2125             :                           PyLong_Type.tp_name);
    2126           0 :                         return -1;
    2127             :                 }
    2128             :         }
    2129           0 :         return 0;
    2130             : }
    2131             : 
    2132             : static PyGetSetDef py_smbsrv_tcon_info_getsetters[] = {
    2133             :         {
    2134             :                 .name = discard_const_p(char, "tid"),
    2135             :                 .get = py_smbsrv_tcon_info_get_tid,
    2136             :                 .set = py_smbsrv_tcon_info_set_tid,
    2137             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    2138             :         },
    2139             :         {
    2140             :                 .name = discard_const_p(char, "share_name"),
    2141             :                 .get = py_smbsrv_tcon_info_get_share_name,
    2142             :                 .set = py_smbsrv_tcon_info_set_share_name,
    2143             :                 .doc = discard_const_p(char, "PIDL-generated element of base type string")
    2144             :         },
    2145             :         {
    2146             :                 .name = discard_const_p(char, "client_ip"),
    2147             :                 .get = py_smbsrv_tcon_info_get_client_ip,
    2148             :                 .set = py_smbsrv_tcon_info_set_client_ip,
    2149             :                 .doc = discard_const_p(char, "PIDL-generated element of base type string")
    2150             :         },
    2151             :         {
    2152             :                 .name = discard_const_p(char, "connect_time"),
    2153             :                 .get = py_smbsrv_tcon_info_get_connect_time,
    2154             :                 .set = py_smbsrv_tcon_info_set_connect_time,
    2155             :                 .doc = discard_const_p(char, "PIDL-generated element of base type NTTIME")
    2156             :         },
    2157             :         {
    2158             :                 .name = discard_const_p(char, "last_use_time"),
    2159             :                 .get = py_smbsrv_tcon_info_get_last_use_time,
    2160             :                 .set = py_smbsrv_tcon_info_set_last_use_time,
    2161             :                 .doc = discard_const_p(char, "PIDL-generated element of base type NTTIME")
    2162             :         },
    2163             :         { .name = NULL }
    2164             : };
    2165             : 
    2166           0 : static PyObject *py_smbsrv_tcon_info_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    2167             : {
    2168           0 :         return pytalloc_new(struct smbsrv_tcon_info, type);
    2169             : }
    2170             : 
    2171             : 
    2172             : static PyTypeObject smbsrv_tcon_info_Type = {
    2173             :         PyVarObject_HEAD_INIT(NULL, 0)
    2174             :         .tp_name = "irpc.smbsrv_tcon_info",
    2175             :         .tp_getset = py_smbsrv_tcon_info_getsetters,
    2176             :         .tp_methods = NULL,
    2177             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    2178             :         .tp_new = py_smbsrv_tcon_info_new,
    2179             : };
    2180             : 
    2181             : 
    2182           0 : static PyObject *py_smbsrv_tcons_get_num_tcons(PyObject *obj, void *closure)
    2183             : {
    2184           0 :         struct smbsrv_tcons *object = pytalloc_get_ptr(obj);
    2185             :         PyObject *py_num_tcons;
    2186           0 :         py_num_tcons = PyLong_FromUnsignedLongLong((uint32_t)(object->num_tcons));
    2187           0 :         return py_num_tcons;
    2188             : }
    2189             : 
    2190           0 : static int py_smbsrv_tcons_set_num_tcons(PyObject *py_obj, PyObject *value, void *closure)
    2191             : {
    2192           0 :         struct smbsrv_tcons *object = pytalloc_get_ptr(py_obj);
    2193           0 :         if (value == NULL) {
    2194           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->num_tcons");
    2195           0 :                 return -1;
    2196             :         }
    2197             :         {
    2198           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->num_tcons));
    2199           0 :                 if (PyLong_Check(value)) {
    2200             :                         unsigned long long test_var;
    2201           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    2202           0 :                         if (PyErr_Occurred() != NULL) {
    2203           0 :                                 return -1;
    2204             :                         }
    2205           0 :                         if (test_var > uint_max) {
    2206           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2207             :                                   PyLong_Type.tp_name, uint_max, test_var);
    2208           0 :                                 return -1;
    2209             :                         }
    2210           0 :                         object->num_tcons = test_var;
    2211             :                 } else {
    2212           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2213             :                           PyLong_Type.tp_name);
    2214           0 :                         return -1;
    2215             :                 }
    2216             :         }
    2217           0 :         return 0;
    2218             : }
    2219             : 
    2220           0 : static PyObject *py_smbsrv_tcons_get_tcons(PyObject *obj, void *closure)
    2221             : {
    2222           0 :         struct smbsrv_tcons *object = pytalloc_get_ptr(obj);
    2223             :         PyObject *py_tcons;
    2224           0 :         if (object->tcons == NULL) {
    2225           0 :                 Py_RETURN_NONE;
    2226             :         }
    2227           0 :         if (object->tcons == NULL) {
    2228           0 :                 py_tcons = Py_None;
    2229           0 :                 Py_INCREF(py_tcons);
    2230             :         } else {
    2231           0 :                 py_tcons = PyList_New(object->num_tcons);
    2232           0 :                 if (py_tcons == NULL) {
    2233           0 :                         return NULL;
    2234             :                 }
    2235             :                 {
    2236             :                         int tcons_cntr_1;
    2237           0 :                         for (tcons_cntr_1 = 0; tcons_cntr_1 < (object->num_tcons); tcons_cntr_1++) {
    2238             :                                 PyObject *py_tcons_1;
    2239           0 :                                 py_tcons_1 = pytalloc_reference_ex(&smbsrv_tcon_info_Type, object->tcons, &(object->tcons)[tcons_cntr_1]);
    2240           0 :                                 PyList_SetItem(py_tcons, tcons_cntr_1, py_tcons_1);
    2241             :                         }
    2242             :                 }
    2243             :         }
    2244           0 :         return py_tcons;
    2245             : }
    2246             : 
    2247           0 : static int py_smbsrv_tcons_set_tcons(PyObject *py_obj, PyObject *value, void *closure)
    2248             : {
    2249           0 :         struct smbsrv_tcons *object = pytalloc_get_ptr(py_obj);
    2250           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->tcons));
    2251           0 :         if (value == NULL) {
    2252           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->tcons");
    2253           0 :                 return -1;
    2254             :         }
    2255           0 :         if (value == Py_None) {
    2256           0 :                 object->tcons = NULL;
    2257             :         } else {
    2258           0 :                 object->tcons = NULL;
    2259           0 :                 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
    2260             :                 {
    2261             :                         int tcons_cntr_1;
    2262           0 :                         object->tcons = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->tcons, PyList_GET_SIZE(value));
    2263           0 :                         if (!object->tcons) { return -1; }
    2264           0 :                         talloc_set_name_const(object->tcons, "ARRAY: object->tcons");
    2265           0 :                         for (tcons_cntr_1 = 0; tcons_cntr_1 < PyList_GET_SIZE(value); tcons_cntr_1++) {
    2266           0 :                                 if (PyList_GET_ITEM(value, tcons_cntr_1) == NULL) {
    2267           0 :                                         PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->tcons)[tcons_cntr_1]");
    2268           0 :                                         return -1;
    2269             :                                 }
    2270           0 :                                 PY_CHECK_TYPE(&smbsrv_tcon_info_Type, PyList_GET_ITEM(value, tcons_cntr_1), return -1;);
    2271           0 :                                 if (talloc_reference(object->tcons, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, tcons_cntr_1))) == NULL) {
    2272           0 :                                         PyErr_NoMemory();
    2273           0 :                                         return -1;
    2274             :                                 }
    2275           0 :                                 (object->tcons)[tcons_cntr_1] = *(struct smbsrv_tcon_info *)pytalloc_get_ptr(PyList_GET_ITEM(value, tcons_cntr_1));
    2276             :                         }
    2277             :                 }
    2278             :         }
    2279           0 :         return 0;
    2280             : }
    2281             : 
    2282             : static PyGetSetDef py_smbsrv_tcons_getsetters[] = {
    2283             :         {
    2284             :                 .name = discard_const_p(char, "num_tcons"),
    2285             :                 .get = py_smbsrv_tcons_get_num_tcons,
    2286             :                 .set = py_smbsrv_tcons_set_num_tcons,
    2287             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    2288             :         },
    2289             :         {
    2290             :                 .name = discard_const_p(char, "tcons"),
    2291             :                 .get = py_smbsrv_tcons_get_tcons,
    2292             :                 .set = py_smbsrv_tcons_set_tcons,
    2293             :                 .doc = discard_const_p(char, "PIDL-generated element of base type smbsrv_tcon_info")
    2294             :         },
    2295             :         { .name = NULL }
    2296             : };
    2297             : 
    2298           0 : static PyObject *py_smbsrv_tcons_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    2299             : {
    2300           0 :         return pytalloc_new(struct smbsrv_tcons, type);
    2301             : }
    2302             : 
    2303             : 
    2304             : static PyTypeObject smbsrv_tcons_Type = {
    2305             :         PyVarObject_HEAD_INIT(NULL, 0)
    2306             :         .tp_name = "irpc.smbsrv_tcons",
    2307             :         .tp_getset = py_smbsrv_tcons_getsetters,
    2308             :         .tp_methods = NULL,
    2309             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    2310             :         .tp_new = py_smbsrv_tcons_new,
    2311             : };
    2312             : 
    2313           0 : static PyObject *py_import_smbsrv_info(TALLOC_CTX *mem_ctx, int level, union smbsrv_info *in)
    2314             : {
    2315             :         PyObject *ret;
    2316             : 
    2317           0 :         switch (level) {
    2318           0 :                 case SMBSRV_INFO_SESSIONS:
    2319           0 :                         ret = pytalloc_reference_ex(&smbsrv_sessions_Type, mem_ctx, &in->sessions);
    2320           0 :                         return ret;
    2321             : 
    2322           0 :                 case SMBSRV_INFO_TCONS:
    2323           0 :                         ret = pytalloc_reference_ex(&smbsrv_tcons_Type, mem_ctx, &in->tcons);
    2324           0 :                         return ret;
    2325             : 
    2326             :         }
    2327           0 :         PyErr_SetString(PyExc_TypeError, "unknown union level");
    2328           0 :         return NULL;
    2329             : }
    2330             : 
    2331           0 : static union smbsrv_info *py_export_smbsrv_info(TALLOC_CTX *mem_ctx, int level, PyObject *in)
    2332             : {
    2333           0 :         union smbsrv_info *ret = talloc_zero(mem_ctx, union smbsrv_info);
    2334           0 :         switch (level) {
    2335           0 :                 case SMBSRV_INFO_SESSIONS:
    2336           0 :                         if (in == NULL) {
    2337           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->sessions");
    2338           0 :                                 talloc_free(ret); return NULL;
    2339             :                         }
    2340           0 :                         PY_CHECK_TYPE(&smbsrv_sessions_Type, in, talloc_free(ret); return NULL;);
    2341           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    2342           0 :                                 PyErr_NoMemory();
    2343           0 :                                 talloc_free(ret); return NULL;
    2344             :                         }
    2345           0 :                         ret->sessions = *(struct smbsrv_sessions *)pytalloc_get_ptr(in);
    2346           0 :                         break;
    2347             : 
    2348           0 :                 case SMBSRV_INFO_TCONS:
    2349           0 :                         if (in == NULL) {
    2350           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->tcons");
    2351           0 :                                 talloc_free(ret); return NULL;
    2352             :                         }
    2353           0 :                         PY_CHECK_TYPE(&smbsrv_tcons_Type, in, talloc_free(ret); return NULL;);
    2354           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    2355           0 :                                 PyErr_NoMemory();
    2356           0 :                                 talloc_free(ret); return NULL;
    2357             :                         }
    2358           0 :                         ret->tcons = *(struct smbsrv_tcons *)pytalloc_get_ptr(in);
    2359           0 :                         break;
    2360             : 
    2361           0 :                 default:
    2362           0 :                         PyErr_SetString(PyExc_TypeError, "invalid union level value");
    2363           0 :                         talloc_free(ret);
    2364           0 :                         ret = NULL;
    2365             :         }
    2366             : 
    2367           0 :         return ret;
    2368             : }
    2369             : 
    2370           0 : static PyObject *py_smbsrv_info_import(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    2371             : {
    2372           0 :         const char * const kwnames[] = { "mem_ctx", "level", "in", NULL };
    2373           0 :         PyObject *mem_ctx_obj = NULL;
    2374           0 :         TALLOC_CTX *mem_ctx = NULL;
    2375           0 :         int level = 0;
    2376           0 :         PyObject *in_obj = NULL;
    2377           0 :         union smbsrv_info *in = NULL;
    2378             : 
    2379           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OiO:import",
    2380             :                 discard_const_p(char *, kwnames),
    2381             :                 &mem_ctx_obj,
    2382             :                 &level,
    2383             :                 &in_obj)) {
    2384           0 :                 return NULL;
    2385             :         }
    2386           0 :         mem_ctx = pytalloc_get_ptr(mem_ctx_obj);
    2387           0 :         if (mem_ctx == NULL) {
    2388           0 :                 PyErr_SetString(PyExc_TypeError, "mem_ctx is NULL)!");
    2389           0 :                 return NULL;
    2390             :         }
    2391           0 :         in = (union smbsrv_info *)pytalloc_get_ptr(in_obj);
    2392           0 :         if (in == NULL) {
    2393           0 :                 PyErr_Format(PyExc_TypeError, "in needs to be a pointer to union smbsrv_info!");
    2394           0 :                 return NULL;
    2395             :         }
    2396             : 
    2397           0 :         return py_import_smbsrv_info(mem_ctx, level, in);
    2398             : }
    2399             : 
    2400           0 : static PyObject *py_smbsrv_info_export(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    2401             : {
    2402           0 :         const char * const kwnames[] = { "mem_ctx", "level", "in", NULL };
    2403           0 :         PyObject *mem_ctx_obj = NULL;
    2404           0 :         TALLOC_CTX *mem_ctx = NULL;
    2405           0 :         int level = 0;
    2406           0 :         PyObject *in = NULL;
    2407           0 :         union smbsrv_info *out = NULL;
    2408             : 
    2409           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OiO:export",
    2410             :                 discard_const_p(char *, kwnames),
    2411             :                 &mem_ctx_obj,
    2412             :                 &level,
    2413             :                 &in)) {
    2414           0 :                 return NULL;
    2415             :         }
    2416           0 :         mem_ctx = pytalloc_get_ptr(mem_ctx_obj);
    2417           0 :         if (mem_ctx == NULL) {
    2418           0 :                 PyErr_SetString(PyExc_TypeError, "mem_ctx is NULL)!");
    2419           0 :                 return NULL;
    2420             :         }
    2421             : 
    2422           0 :         out = py_export_smbsrv_info(mem_ctx, level, in);
    2423           0 :         if (out == NULL) {
    2424           0 :                 return NULL;
    2425             :         }
    2426             : 
    2427           0 :         return pytalloc_GenericObject_reference(out);
    2428             : }
    2429             : 
    2430             : static PyMethodDef py_smbsrv_info_methods[] = {
    2431             :         { "__import__", PY_DISCARD_FUNC_SIG(PyCFunction,py_smbsrv_info_import),
    2432             :                 METH_VARARGS|METH_KEYWORDS|METH_CLASS,
    2433             :                 "T.__import__(mem_ctx, level, in) => ret." },
    2434             :         { "__export__", PY_DISCARD_FUNC_SIG(PyCFunction,py_smbsrv_info_export),
    2435             :                 METH_VARARGS|METH_KEYWORDS|METH_CLASS,
    2436             :                 "T.__export__(mem_ctx, level, in) => ret." },
    2437             :         { NULL, NULL, 0, NULL }
    2438             : };
    2439             : 
    2440           0 : static PyObject *py_smbsrv_info_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    2441             : {
    2442           0 :         PyErr_Format(PyExc_TypeError, "New %s Objects are not supported", type->tp_name);
    2443           0 :         return NULL;
    2444             : }
    2445             : 
    2446             : 
    2447             : static PyTypeObject smbsrv_info_Type = {
    2448             :         PyVarObject_HEAD_INIT(NULL, 0)
    2449             :         .tp_name = "irpc.smbsrv_info",
    2450             :         .tp_getset = NULL,
    2451             :         .tp_methods = py_smbsrv_info_methods,
    2452             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    2453             :         .tp_new = py_smbsrv_info_new,
    2454             : };
    2455             : 
    2456             : 
    2457             : 
    2458           0 : static PyObject *py_irpc_uptime_out_get_start_time(PyObject *obj, void *closure)
    2459             : {
    2460           0 :         struct irpc_uptime *object = pytalloc_get_ptr(obj);
    2461             :         PyObject *py_start_time;
    2462           0 :         if (object->out.start_time == NULL) {
    2463           0 :                 Py_RETURN_NONE;
    2464             :         }
    2465           0 :         py_start_time = PyLong_FromUnsignedLongLong(*object->out.start_time);
    2466           0 :         return py_start_time;
    2467             : }
    2468             : 
    2469           0 : static int py_irpc_uptime_out_set_start_time(PyObject *py_obj, PyObject *value, void *closure)
    2470             : {
    2471           0 :         struct irpc_uptime *object = pytalloc_get_ptr(py_obj);
    2472           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.start_time));
    2473           0 :         if (value == NULL) {
    2474           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.start_time");
    2475           0 :                 return -1;
    2476             :         }
    2477           0 :         object->out.start_time = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.start_time);
    2478           0 :         if (object->out.start_time == NULL) {
    2479           0 :                 PyErr_NoMemory();
    2480           0 :                 return -1;
    2481             :         }
    2482             :         {
    2483           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->out.start_time));
    2484           0 :                 if (PyLong_Check(value)) {
    2485             :                         unsigned long long test_var;
    2486           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    2487           0 :                         if (PyErr_Occurred() != NULL) {
    2488           0 :                                 return -1;
    2489             :                         }
    2490           0 :                         if (test_var > uint_max) {
    2491           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2492             :                                   PyLong_Type.tp_name, uint_max, test_var);
    2493           0 :                                 return -1;
    2494             :                         }
    2495           0 :                         *object->out.start_time = test_var;
    2496             :                 } else {
    2497           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2498             :                           PyLong_Type.tp_name);
    2499           0 :                         return -1;
    2500             :                 }
    2501             :         }
    2502           0 :         return 0;
    2503             : }
    2504             : 
    2505             : static PyGetSetDef py_irpc_uptime_getsetters[] = {
    2506             :         {
    2507             :                 .name = discard_const_p(char, "out_start_time"),
    2508             :                 .get = py_irpc_uptime_out_get_start_time,
    2509             :                 .set = py_irpc_uptime_out_set_start_time,
    2510             :                 .doc = discard_const_p(char, "PIDL-generated element of base type NTTIME")
    2511             :         },
    2512             :         { .name = NULL }
    2513             : };
    2514             : 
    2515           0 : static PyObject *py_irpc_uptime_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    2516             : {
    2517           0 :         PyObject *self = pytalloc_new(struct irpc_uptime, type);
    2518           0 :         struct irpc_uptime *_self = (struct irpc_uptime *)pytalloc_get_ptr(self);
    2519           0 :         TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
    2520           0 :         _self->out.start_time = talloc_zero(mem_ctx, NTTIME);
    2521           0 :         return self;
    2522             : }
    2523             : 
    2524           0 : static PyObject *py_irpc_uptime_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
    2525             : {
    2526             : 
    2527             : 
    2528           0 :         return PyLong_FromLong(0);
    2529             : }
    2530             : 
    2531           0 : static PyObject *py_irpc_uptime_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
    2532             : {
    2533           0 :         const struct ndr_interface_call *call = NULL;
    2534           0 :         struct irpc_uptime *object = pytalloc_get_ptr(py_obj);
    2535           0 :         PyObject *ret = NULL;
    2536           0 :         struct ndr_push *push = NULL;
    2537             :         DATA_BLOB blob;
    2538             :         enum ndr_err_code err;
    2539             : 
    2540           0 :         if (ndr_table_irpc.num_calls < 1) {
    2541           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_irpc_uptime_ndr_pack");
    2542           0 :                 return NULL;
    2543             :         }
    2544           0 :         call = &ndr_table_irpc.calls[0];
    2545             : 
    2546           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
    2547           0 :         if (push == NULL) {
    2548           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    2549           0 :                 return NULL;
    2550             :         }
    2551             : 
    2552           0 :         push->flags |= ndr_push_flags;
    2553             : 
    2554           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
    2555           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    2556           0 :                 TALLOC_FREE(push);
    2557           0 :                 PyErr_SetNdrError(err);
    2558           0 :                 return NULL;
    2559             :         }
    2560           0 :         blob = ndr_push_blob(push);
    2561           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
    2562           0 :         TALLOC_FREE(push);
    2563           0 :         return ret;
    2564             : }
    2565             : 
    2566           0 : static PyObject *py_irpc_uptime_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    2567             : {
    2568           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    2569           0 :         PyObject *bigendian_obj = NULL;
    2570           0 :         PyObject *ndr64_obj = NULL;
    2571           0 :         libndr_flags ndr_push_flags = 0;
    2572             : 
    2573           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
    2574             :                 discard_const_p(char *, kwnames),
    2575             :                 &bigendian_obj,
    2576             :                 &ndr64_obj)) {
    2577           0 :                 return NULL;
    2578             :         }
    2579             : 
    2580           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    2581           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    2582             :         }
    2583           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    2584           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    2585             :         }
    2586             : 
    2587           0 :         return py_irpc_uptime_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
    2588             : }
    2589             : 
    2590           0 : static PyObject *py_irpc_uptime_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    2591             : {
    2592           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    2593           0 :         PyObject *bigendian_obj = NULL;
    2594           0 :         PyObject *ndr64_obj = NULL;
    2595           0 :         libndr_flags ndr_push_flags = 0;
    2596             : 
    2597           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
    2598             :                 discard_const_p(char *, kwnames),
    2599             :                 &bigendian_obj,
    2600             :                 &ndr64_obj)) {
    2601           0 :                 return NULL;
    2602             :         }
    2603             : 
    2604           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    2605           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    2606             :         }
    2607           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    2608           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    2609             :         }
    2610             : 
    2611           0 :         return py_irpc_uptime_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
    2612             : }
    2613             : 
    2614           0 : static PyObject *py_irpc_uptime_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
    2615             : {
    2616           0 :         const struct ndr_interface_call *call = NULL;
    2617           0 :         struct irpc_uptime *object = pytalloc_get_ptr(py_obj);
    2618           0 :         struct ndr_pull *pull = NULL;
    2619             :         enum ndr_err_code err;
    2620             : 
    2621           0 :         if (ndr_table_irpc.num_calls < 1) {
    2622           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_irpc_uptime_ndr_unpack");
    2623           0 :                 return NULL;
    2624             :         }
    2625           0 :         call = &ndr_table_irpc.calls[0];
    2626             : 
    2627           0 :         pull = ndr_pull_init_blob(blob, object);
    2628           0 :         if (pull == NULL) {
    2629           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    2630           0 :                 return NULL;
    2631             :         }
    2632             : 
    2633           0 :         pull->flags |= ndr_pull_flags;
    2634             : 
    2635           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
    2636           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    2637           0 :                 TALLOC_FREE(pull);
    2638           0 :                 PyErr_SetNdrError(err);
    2639           0 :                 return NULL;
    2640             :         }
    2641           0 :         if (!allow_remaining) {
    2642             :                 uint32_t highest_ofs;
    2643             : 
    2644           0 :                 if (pull->offset > pull->relative_highest_offset) {
    2645           0 :                         highest_ofs = pull->offset;
    2646             :                 } else {
    2647           0 :                         highest_ofs = pull->relative_highest_offset;
    2648             :                 }
    2649           0 :                 if (highest_ofs < pull->data_size) {
    2650           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
    2651             :                                 "not all bytes consumed ofs[%u] size[%u]",
    2652             :                                 highest_ofs, pull->data_size);
    2653           0 :                         TALLOC_FREE(pull);
    2654           0 :                         PyErr_SetNdrError(err);
    2655           0 :                         return NULL;
    2656             :                 }
    2657             :         }
    2658             : 
    2659           0 :         TALLOC_FREE(pull);
    2660           0 :         Py_RETURN_NONE;
    2661             : }
    2662             : 
    2663           0 : static PyObject *py_irpc_uptime_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    2664             : {
    2665             :         DATA_BLOB blob;
    2666           0 :         Py_ssize_t blob_length = 0;
    2667           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    2668           0 :         PyObject *bigendian_obj = NULL;
    2669           0 :         PyObject *ndr64_obj = NULL;
    2670           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    2671           0 :         PyObject *allow_remaining_obj = NULL;
    2672           0 :         bool allow_remaining = false;
    2673             : 
    2674           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
    2675             :                 discard_const_p(char *, kwnames),
    2676             :                 &blob.data, &blob_length,
    2677             :                 &bigendian_obj,
    2678             :                 &ndr64_obj,
    2679             :                 &allow_remaining_obj)) {
    2680           0 :                 return NULL;
    2681             :         }
    2682           0 :         blob.length = blob_length;
    2683             : 
    2684           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    2685           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    2686             :         }
    2687           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    2688           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    2689             :         }
    2690             : 
    2691           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    2692           0 :                 allow_remaining = true;
    2693             :         }
    2694             : 
    2695           0 :         return py_irpc_uptime_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
    2696             : }
    2697             : 
    2698           0 : static PyObject *py_irpc_uptime_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    2699             : {
    2700             :         DATA_BLOB blob;
    2701           0 :         Py_ssize_t blob_length = 0;
    2702           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    2703           0 :         PyObject *bigendian_obj = NULL;
    2704           0 :         PyObject *ndr64_obj = NULL;
    2705           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    2706           0 :         PyObject *allow_remaining_obj = NULL;
    2707           0 :         bool allow_remaining = false;
    2708             : 
    2709           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
    2710             :                 discard_const_p(char *, kwnames),
    2711             :                 &blob.data, &blob_length,
    2712             :                 &bigendian_obj,
    2713             :                 &ndr64_obj,
    2714             :                 &allow_remaining_obj)) {
    2715           0 :                 return NULL;
    2716             :         }
    2717           0 :         blob.length = blob_length;
    2718             : 
    2719           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    2720           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    2721             :         }
    2722           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    2723           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    2724             :         }
    2725             : 
    2726           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    2727           0 :                 allow_remaining = true;
    2728             :         }
    2729             : 
    2730           0 :         return py_irpc_uptime_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
    2731             : }
    2732             : 
    2733           0 : static PyObject *py_irpc_uptime_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
    2734             : {
    2735           0 :         const struct ndr_interface_call *call = NULL;
    2736           0 :         struct irpc_uptime *object = pytalloc_get_ptr(py_obj);
    2737             :         PyObject *ret;
    2738             :         char *retstr;
    2739             : 
    2740           0 :         if (ndr_table_irpc.num_calls < 1) {
    2741           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_irpc_uptime_ndr_print");
    2742           0 :                 return NULL;
    2743             :         }
    2744           0 :         call = &ndr_table_irpc.calls[0];
    2745             : 
    2746           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
    2747           0 :         ret = PyUnicode_FromString(retstr);
    2748           0 :         TALLOC_FREE(retstr);
    2749             : 
    2750           0 :         return ret;
    2751             : }
    2752             : 
    2753           0 : static PyObject *py_irpc_uptime_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    2754             : {
    2755           0 :         return py_irpc_uptime_ndr_print(py_obj, "irpc_uptime_in", NDR_IN);
    2756             : }
    2757             : 
    2758           0 : static PyObject *py_irpc_uptime_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    2759             : {
    2760           0 :         return py_irpc_uptime_ndr_print(py_obj, "irpc_uptime_out", NDR_OUT);
    2761             : }
    2762             : 
    2763             : static PyMethodDef py_irpc_uptime_methods[] = {
    2764             :         { "opnum", (PyCFunction)py_irpc_uptime_ndr_opnum, METH_NOARGS|METH_CLASS,
    2765             :                 "irpc.uptime.opnum() -> 0 (0x00) " },
    2766             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_irpc_uptime_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
    2767             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
    2768             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_irpc_uptime_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
    2769             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
    2770             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_irpc_uptime_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
    2771             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
    2772             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_irpc_uptime_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
    2773             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
    2774             :         { "__ndr_print_in__", (PyCFunction)py_irpc_uptime_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
    2775             :         { "__ndr_print_out__", (PyCFunction)py_irpc_uptime_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
    2776             :         { NULL, NULL, 0, NULL }
    2777             : };
    2778             : 
    2779             : 
    2780             : static PyTypeObject irpc_uptime_Type = {
    2781             :         PyVarObject_HEAD_INIT(NULL, 0)
    2782             :         .tp_name = "irpc.uptime",
    2783             :         .tp_getset = py_irpc_uptime_getsetters,
    2784             :         .tp_methods = py_irpc_uptime_methods,
    2785             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    2786             :         .tp_new = py_irpc_uptime_new,
    2787             : };
    2788             : 
    2789           0 : static bool pack_py_irpc_uptime_args_in(PyObject *args, PyObject *kwargs, struct irpc_uptime *r)
    2790             : {
    2791           0 :         const char *kwnames[] = {
    2792             :                 NULL
    2793             :         };
    2794             : 
    2795           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, ":irpc_uptime", discard_const_p(char *, kwnames))) {
    2796           0 :                 return false;
    2797             :         }
    2798             : 
    2799           0 :         return true;
    2800             : }
    2801             : 
    2802           0 : static PyObject *unpack_py_irpc_uptime_args_out(struct irpc_uptime *r)
    2803             : {
    2804             :         PyObject *result;
    2805             :         PyObject *py_start_time;
    2806           0 :         py_start_time = PyLong_FromUnsignedLongLong(*r->out.start_time);
    2807           0 :         result = py_start_time;
    2808           0 :         return result;
    2809             : }
    2810             : 
    2811             : 
    2812           0 : static PyObject *py_nbtd_information_in_get_level(PyObject *obj, void *closure)
    2813             : {
    2814           0 :         struct nbtd_information *object = pytalloc_get_ptr(obj);
    2815             :         PyObject *py_level;
    2816           0 :         py_level = PyLong_FromUnsignedLongLong((uint32_t)(object->in.level));
    2817           0 :         return py_level;
    2818             : }
    2819             : 
    2820           0 : static int py_nbtd_information_in_set_level(PyObject *py_obj, PyObject *value, void *closure)
    2821             : {
    2822           0 :         struct nbtd_information *object = pytalloc_get_ptr(py_obj);
    2823           0 :         if (value == NULL) {
    2824           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.level");
    2825           0 :                 return -1;
    2826             :         }
    2827             :         {
    2828           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.level));
    2829           0 :                 if (PyLong_Check(value)) {
    2830             :                         unsigned long long test_var;
    2831           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    2832           0 :                         if (PyErr_Occurred() != NULL) {
    2833           0 :                                 return -1;
    2834             :                         }
    2835           0 :                         if (test_var > uint_max) {
    2836           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2837             :                                   PyLong_Type.tp_name, uint_max, test_var);
    2838           0 :                                 return -1;
    2839             :                         }
    2840           0 :                         object->in.level = test_var;
    2841             :                 } else {
    2842           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2843             :                           PyLong_Type.tp_name);
    2844           0 :                         return -1;
    2845             :                 }
    2846             :         }
    2847           0 :         return 0;
    2848             : }
    2849             : 
    2850           0 : static PyObject *py_nbtd_information_out_get_info(PyObject *obj, void *closure)
    2851             : {
    2852           0 :         struct nbtd_information *object = pytalloc_get_ptr(obj);
    2853             :         PyObject *py_info;
    2854           0 :         py_info = pyrpc_import_union(&nbtd_info_Type, pytalloc_get_mem_ctx(obj), object->in.level, &object->out.info, "union nbtd_info");
    2855           0 :         if (py_info == NULL) {
    2856           0 :                 return NULL;
    2857             :         }
    2858           0 :         return py_info;
    2859             : }
    2860             : 
    2861           0 : static int py_nbtd_information_out_set_info(PyObject *py_obj, PyObject *value, void *closure)
    2862             : {
    2863           0 :         struct nbtd_information *object = pytalloc_get_ptr(py_obj);
    2864           0 :         if (value == NULL) {
    2865           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.info");
    2866           0 :                 return -1;
    2867             :         }
    2868             :         {
    2869             :                 union nbtd_info *info_switch_0;
    2870           0 :                 info_switch_0 = (union nbtd_info *)pyrpc_export_union(&nbtd_info_Type, pytalloc_get_mem_ctx(py_obj), object->in.level, value, "union nbtd_info");
    2871           0 :                 if (info_switch_0 == NULL) {
    2872           0 :                         return -1;
    2873             :                 }
    2874           0 :                 object->out.info = *info_switch_0;
    2875             :         }
    2876           0 :         return 0;
    2877             : }
    2878             : 
    2879             : static PyGetSetDef py_nbtd_information_getsetters[] = {
    2880             :         {
    2881             :                 .name = discard_const_p(char, "in_level"),
    2882             :                 .get = py_nbtd_information_in_get_level,
    2883             :                 .set = py_nbtd_information_in_set_level,
    2884             :                 .doc = discard_const_p(char, "PIDL-generated element of base type nbtd_info_level")
    2885             :         },
    2886             :         {
    2887             :                 .name = discard_const_p(char, "out_info"),
    2888             :                 .get = py_nbtd_information_out_get_info,
    2889             :                 .set = py_nbtd_information_out_set_info,
    2890             :                 .doc = discard_const_p(char, "PIDL-generated element of base type nbtd_info")
    2891             :         },
    2892             :         { .name = NULL }
    2893             : };
    2894             : 
    2895           0 : static PyObject *py_nbtd_information_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    2896             : {
    2897           0 :         PyObject *self = pytalloc_new(struct nbtd_information, type);
    2898           0 :         return self;
    2899             : }
    2900             : 
    2901           0 : static PyObject *py_nbtd_information_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
    2902             : {
    2903             : 
    2904             : 
    2905           0 :         return PyLong_FromLong(1);
    2906             : }
    2907             : 
    2908           0 : static PyObject *py_nbtd_information_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
    2909             : {
    2910           0 :         const struct ndr_interface_call *call = NULL;
    2911           0 :         struct nbtd_information *object = pytalloc_get_ptr(py_obj);
    2912           0 :         PyObject *ret = NULL;
    2913           0 :         struct ndr_push *push = NULL;
    2914             :         DATA_BLOB blob;
    2915             :         enum ndr_err_code err;
    2916             : 
    2917           0 :         if (ndr_table_irpc.num_calls < 2) {
    2918           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_nbtd_information_ndr_pack");
    2919           0 :                 return NULL;
    2920             :         }
    2921           0 :         call = &ndr_table_irpc.calls[1];
    2922             : 
    2923           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
    2924           0 :         if (push == NULL) {
    2925           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    2926           0 :                 return NULL;
    2927             :         }
    2928             : 
    2929           0 :         push->flags |= ndr_push_flags;
    2930             : 
    2931           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
    2932           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    2933           0 :                 TALLOC_FREE(push);
    2934           0 :                 PyErr_SetNdrError(err);
    2935           0 :                 return NULL;
    2936             :         }
    2937           0 :         blob = ndr_push_blob(push);
    2938           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
    2939           0 :         TALLOC_FREE(push);
    2940           0 :         return ret;
    2941             : }
    2942             : 
    2943           0 : static PyObject *py_nbtd_information_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    2944             : {
    2945           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    2946           0 :         PyObject *bigendian_obj = NULL;
    2947           0 :         PyObject *ndr64_obj = NULL;
    2948           0 :         libndr_flags ndr_push_flags = 0;
    2949             : 
    2950           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
    2951             :                 discard_const_p(char *, kwnames),
    2952             :                 &bigendian_obj,
    2953             :                 &ndr64_obj)) {
    2954           0 :                 return NULL;
    2955             :         }
    2956             : 
    2957           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    2958           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    2959             :         }
    2960           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    2961           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    2962             :         }
    2963             : 
    2964           0 :         return py_nbtd_information_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
    2965             : }
    2966             : 
    2967           0 : static PyObject *py_nbtd_information_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    2968             : {
    2969           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    2970           0 :         PyObject *bigendian_obj = NULL;
    2971           0 :         PyObject *ndr64_obj = NULL;
    2972           0 :         libndr_flags ndr_push_flags = 0;
    2973             : 
    2974           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
    2975             :                 discard_const_p(char *, kwnames),
    2976             :                 &bigendian_obj,
    2977             :                 &ndr64_obj)) {
    2978           0 :                 return NULL;
    2979             :         }
    2980             : 
    2981           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    2982           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    2983             :         }
    2984           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    2985           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    2986             :         }
    2987             : 
    2988           0 :         return py_nbtd_information_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
    2989             : }
    2990             : 
    2991           0 : static PyObject *py_nbtd_information_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
    2992             : {
    2993           0 :         const struct ndr_interface_call *call = NULL;
    2994           0 :         struct nbtd_information *object = pytalloc_get_ptr(py_obj);
    2995           0 :         struct ndr_pull *pull = NULL;
    2996             :         enum ndr_err_code err;
    2997             : 
    2998           0 :         if (ndr_table_irpc.num_calls < 2) {
    2999           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_nbtd_information_ndr_unpack");
    3000           0 :                 return NULL;
    3001             :         }
    3002           0 :         call = &ndr_table_irpc.calls[1];
    3003             : 
    3004           0 :         pull = ndr_pull_init_blob(blob, object);
    3005           0 :         if (pull == NULL) {
    3006           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    3007           0 :                 return NULL;
    3008             :         }
    3009             : 
    3010           0 :         pull->flags |= ndr_pull_flags;
    3011             : 
    3012           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
    3013           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    3014           0 :                 TALLOC_FREE(pull);
    3015           0 :                 PyErr_SetNdrError(err);
    3016           0 :                 return NULL;
    3017             :         }
    3018           0 :         if (!allow_remaining) {
    3019             :                 uint32_t highest_ofs;
    3020             : 
    3021           0 :                 if (pull->offset > pull->relative_highest_offset) {
    3022           0 :                         highest_ofs = pull->offset;
    3023             :                 } else {
    3024           0 :                         highest_ofs = pull->relative_highest_offset;
    3025             :                 }
    3026           0 :                 if (highest_ofs < pull->data_size) {
    3027           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
    3028             :                                 "not all bytes consumed ofs[%u] size[%u]",
    3029             :                                 highest_ofs, pull->data_size);
    3030           0 :                         TALLOC_FREE(pull);
    3031           0 :                         PyErr_SetNdrError(err);
    3032           0 :                         return NULL;
    3033             :                 }
    3034             :         }
    3035             : 
    3036           0 :         TALLOC_FREE(pull);
    3037           0 :         Py_RETURN_NONE;
    3038             : }
    3039             : 
    3040           0 : static PyObject *py_nbtd_information_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    3041             : {
    3042             :         DATA_BLOB blob;
    3043           0 :         Py_ssize_t blob_length = 0;
    3044           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    3045           0 :         PyObject *bigendian_obj = NULL;
    3046           0 :         PyObject *ndr64_obj = NULL;
    3047           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    3048           0 :         PyObject *allow_remaining_obj = NULL;
    3049           0 :         bool allow_remaining = false;
    3050             : 
    3051           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
    3052             :                 discard_const_p(char *, kwnames),
    3053             :                 &blob.data, &blob_length,
    3054             :                 &bigendian_obj,
    3055             :                 &ndr64_obj,
    3056             :                 &allow_remaining_obj)) {
    3057           0 :                 return NULL;
    3058             :         }
    3059           0 :         blob.length = blob_length;
    3060             : 
    3061           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    3062           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    3063             :         }
    3064           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    3065           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    3066             :         }
    3067             : 
    3068           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    3069           0 :                 allow_remaining = true;
    3070             :         }
    3071             : 
    3072           0 :         return py_nbtd_information_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
    3073             : }
    3074             : 
    3075           0 : static PyObject *py_nbtd_information_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    3076             : {
    3077             :         DATA_BLOB blob;
    3078           0 :         Py_ssize_t blob_length = 0;
    3079           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    3080           0 :         PyObject *bigendian_obj = NULL;
    3081           0 :         PyObject *ndr64_obj = NULL;
    3082           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    3083           0 :         PyObject *allow_remaining_obj = NULL;
    3084           0 :         bool allow_remaining = false;
    3085             : 
    3086           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
    3087             :                 discard_const_p(char *, kwnames),
    3088             :                 &blob.data, &blob_length,
    3089             :                 &bigendian_obj,
    3090             :                 &ndr64_obj,
    3091             :                 &allow_remaining_obj)) {
    3092           0 :                 return NULL;
    3093             :         }
    3094           0 :         blob.length = blob_length;
    3095             : 
    3096           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    3097           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    3098             :         }
    3099           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    3100           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    3101             :         }
    3102             : 
    3103           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    3104           0 :                 allow_remaining = true;
    3105             :         }
    3106             : 
    3107           0 :         return py_nbtd_information_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
    3108             : }
    3109             : 
    3110           0 : static PyObject *py_nbtd_information_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
    3111             : {
    3112           0 :         const struct ndr_interface_call *call = NULL;
    3113           0 :         struct nbtd_information *object = pytalloc_get_ptr(py_obj);
    3114             :         PyObject *ret;
    3115             :         char *retstr;
    3116             : 
    3117           0 :         if (ndr_table_irpc.num_calls < 2) {
    3118           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_nbtd_information_ndr_print");
    3119           0 :                 return NULL;
    3120             :         }
    3121           0 :         call = &ndr_table_irpc.calls[1];
    3122             : 
    3123           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
    3124           0 :         ret = PyUnicode_FromString(retstr);
    3125           0 :         TALLOC_FREE(retstr);
    3126             : 
    3127           0 :         return ret;
    3128             : }
    3129             : 
    3130           0 : static PyObject *py_nbtd_information_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    3131             : {
    3132           0 :         return py_nbtd_information_ndr_print(py_obj, "nbtd_information_in", NDR_IN);
    3133             : }
    3134             : 
    3135           0 : static PyObject *py_nbtd_information_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    3136             : {
    3137           0 :         return py_nbtd_information_ndr_print(py_obj, "nbtd_information_out", NDR_OUT);
    3138             : }
    3139             : 
    3140             : static PyMethodDef py_nbtd_information_methods[] = {
    3141             :         { "opnum", (PyCFunction)py_nbtd_information_ndr_opnum, METH_NOARGS|METH_CLASS,
    3142             :                 "irpc.nbtd_information.opnum() -> 1 (0x01) " },
    3143             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_nbtd_information_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
    3144             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
    3145             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_nbtd_information_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
    3146             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
    3147             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_nbtd_information_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
    3148             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
    3149             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_nbtd_information_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
    3150             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
    3151             :         { "__ndr_print_in__", (PyCFunction)py_nbtd_information_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
    3152             :         { "__ndr_print_out__", (PyCFunction)py_nbtd_information_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
    3153             :         { NULL, NULL, 0, NULL }
    3154             : };
    3155             : 
    3156             : 
    3157             : static PyTypeObject nbtd_information_Type = {
    3158             :         PyVarObject_HEAD_INIT(NULL, 0)
    3159             :         .tp_name = "irpc.nbtd_information",
    3160             :         .tp_getset = py_nbtd_information_getsetters,
    3161             :         .tp_methods = py_nbtd_information_methods,
    3162             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    3163             :         .tp_new = py_nbtd_information_new,
    3164             : };
    3165             : 
    3166           0 : static bool pack_py_nbtd_information_args_in(PyObject *args, PyObject *kwargs, struct nbtd_information *r)
    3167             : {
    3168             :         PyObject *py_level;
    3169           0 :         const char *kwnames[] = {
    3170             :                 "level", NULL
    3171             :         };
    3172             : 
    3173           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:nbtd_information", discard_const_p(char *, kwnames), &py_level)) {
    3174           0 :                 return false;
    3175             :         }
    3176             : 
    3177           0 :         if (py_level == NULL) {
    3178           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.level");
    3179           0 :                 return false;
    3180             :         }
    3181             :         {
    3182           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.level));
    3183           0 :                 if (PyLong_Check(py_level)) {
    3184             :                         unsigned long long test_var;
    3185           0 :                         test_var = PyLong_AsUnsignedLongLong(py_level);
    3186           0 :                         if (PyErr_Occurred() != NULL) {
    3187           0 :                                 return false;
    3188             :                         }
    3189           0 :                         if (test_var > uint_max) {
    3190           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3191             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3192           0 :                                 return false;
    3193             :                         }
    3194           0 :                         r->in.level = test_var;
    3195             :                 } else {
    3196           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3197             :                           PyLong_Type.tp_name);
    3198           0 :                         return false;
    3199             :                 }
    3200             :         }
    3201           0 :         return true;
    3202             : }
    3203             : 
    3204           0 : static PyObject *unpack_py_nbtd_information_args_out(struct nbtd_information *r)
    3205             : {
    3206             :         PyObject *result;
    3207             :         PyObject *py_info;
    3208           0 :         py_info = pyrpc_import_union(&nbtd_info_Type, r, r->in.level, &r->out.info, "union nbtd_info");
    3209           0 :         if (py_info == NULL) {
    3210           0 :                 return NULL;
    3211             :         }
    3212           0 :         result = py_info;
    3213           0 :         return result;
    3214             : }
    3215             : 
    3216             : 
    3217           0 : static PyObject *py_nbtd_getdcname_in_get_domainname(PyObject *obj, void *closure)
    3218             : {
    3219           0 :         struct nbtd_getdcname *object = pytalloc_get_ptr(obj);
    3220             :         PyObject *py_domainname;
    3221           0 :         py_domainname = PyString_FromStringOrNULL(object->in.domainname);
    3222           0 :         return py_domainname;
    3223             : }
    3224             : 
    3225           0 : static int py_nbtd_getdcname_in_set_domainname(PyObject *py_obj, PyObject *value, void *closure)
    3226             : {
    3227           0 :         struct nbtd_getdcname *object = pytalloc_get_ptr(py_obj);
    3228           0 :         if (value == NULL) {
    3229           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.domainname");
    3230           0 :                 return -1;
    3231             :         }
    3232             :         {
    3233             :                 const char *test_str;
    3234             :                 const char *talloc_str;
    3235           0 :                 PyObject *unicode = NULL;
    3236           0 :                 if (PyUnicode_Check(value)) {
    3237           0 :                         unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    3238           0 :                         if (unicode == NULL) {
    3239           0 :                                 return -1;
    3240             :                         }
    3241           0 :                         test_str = PyBytes_AS_STRING(unicode);
    3242           0 :                 } else if (PyBytes_Check(value)) {
    3243           0 :                         test_str = PyBytes_AS_STRING(value);
    3244             :                 } else {
    3245           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    3246           0 :                         return -1;
    3247             :                 }
    3248           0 :                 talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    3249           0 :                 if (unicode != NULL) {
    3250           0 :                         Py_DECREF(unicode);
    3251             :                 }
    3252           0 :                 if (talloc_str == NULL) {
    3253           0 :                         PyErr_NoMemory();
    3254           0 :                         return -1;
    3255             :                 }
    3256           0 :                 object->in.domainname = talloc_str;
    3257             :         }
    3258           0 :         return 0;
    3259             : }
    3260             : 
    3261           0 : static PyObject *py_nbtd_getdcname_in_get_ip_address(PyObject *obj, void *closure)
    3262             : {
    3263           0 :         struct nbtd_getdcname *object = pytalloc_get_ptr(obj);
    3264             :         PyObject *py_ip_address;
    3265           0 :         py_ip_address = PyString_FromStringOrNULL(object->in.ip_address);
    3266           0 :         return py_ip_address;
    3267             : }
    3268             : 
    3269           0 : static int py_nbtd_getdcname_in_set_ip_address(PyObject *py_obj, PyObject *value, void *closure)
    3270             : {
    3271           0 :         struct nbtd_getdcname *object = pytalloc_get_ptr(py_obj);
    3272           0 :         if (value == NULL) {
    3273           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.ip_address");
    3274           0 :                 return -1;
    3275             :         }
    3276             :         {
    3277             :                 const char *test_str;
    3278             :                 const char *talloc_str;
    3279           0 :                 PyObject *unicode = NULL;
    3280           0 :                 if (PyUnicode_Check(value)) {
    3281           0 :                         unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    3282           0 :                         if (unicode == NULL) {
    3283           0 :                                 return -1;
    3284             :                         }
    3285           0 :                         test_str = PyBytes_AS_STRING(unicode);
    3286           0 :                 } else if (PyBytes_Check(value)) {
    3287           0 :                         test_str = PyBytes_AS_STRING(value);
    3288             :                 } else {
    3289           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    3290           0 :                         return -1;
    3291             :                 }
    3292           0 :                 talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    3293           0 :                 if (unicode != NULL) {
    3294           0 :                         Py_DECREF(unicode);
    3295             :                 }
    3296           0 :                 if (talloc_str == NULL) {
    3297           0 :                         PyErr_NoMemory();
    3298           0 :                         return -1;
    3299             :                 }
    3300           0 :                 object->in.ip_address = talloc_str;
    3301             :         }
    3302           0 :         return 0;
    3303             : }
    3304             : 
    3305           0 : static PyObject *py_nbtd_getdcname_in_get_my_computername(PyObject *obj, void *closure)
    3306             : {
    3307           0 :         struct nbtd_getdcname *object = pytalloc_get_ptr(obj);
    3308             :         PyObject *py_my_computername;
    3309           0 :         py_my_computername = PyString_FromStringOrNULL(object->in.my_computername);
    3310           0 :         return py_my_computername;
    3311             : }
    3312             : 
    3313           0 : static int py_nbtd_getdcname_in_set_my_computername(PyObject *py_obj, PyObject *value, void *closure)
    3314             : {
    3315           0 :         struct nbtd_getdcname *object = pytalloc_get_ptr(py_obj);
    3316           0 :         if (value == NULL) {
    3317           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.my_computername");
    3318           0 :                 return -1;
    3319             :         }
    3320             :         {
    3321             :                 const char *test_str;
    3322             :                 const char *talloc_str;
    3323           0 :                 PyObject *unicode = NULL;
    3324           0 :                 if (PyUnicode_Check(value)) {
    3325           0 :                         unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    3326           0 :                         if (unicode == NULL) {
    3327           0 :                                 return -1;
    3328             :                         }
    3329           0 :                         test_str = PyBytes_AS_STRING(unicode);
    3330           0 :                 } else if (PyBytes_Check(value)) {
    3331           0 :                         test_str = PyBytes_AS_STRING(value);
    3332             :                 } else {
    3333           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    3334           0 :                         return -1;
    3335             :                 }
    3336           0 :                 talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    3337           0 :                 if (unicode != NULL) {
    3338           0 :                         Py_DECREF(unicode);
    3339             :                 }
    3340           0 :                 if (talloc_str == NULL) {
    3341           0 :                         PyErr_NoMemory();
    3342           0 :                         return -1;
    3343             :                 }
    3344           0 :                 object->in.my_computername = talloc_str;
    3345             :         }
    3346           0 :         return 0;
    3347             : }
    3348             : 
    3349           0 : static PyObject *py_nbtd_getdcname_in_get_my_accountname(PyObject *obj, void *closure)
    3350             : {
    3351           0 :         struct nbtd_getdcname *object = pytalloc_get_ptr(obj);
    3352             :         PyObject *py_my_accountname;
    3353           0 :         py_my_accountname = PyString_FromStringOrNULL(object->in.my_accountname);
    3354           0 :         return py_my_accountname;
    3355             : }
    3356             : 
    3357           0 : static int py_nbtd_getdcname_in_set_my_accountname(PyObject *py_obj, PyObject *value, void *closure)
    3358             : {
    3359           0 :         struct nbtd_getdcname *object = pytalloc_get_ptr(py_obj);
    3360           0 :         if (value == NULL) {
    3361           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.my_accountname");
    3362           0 :                 return -1;
    3363             :         }
    3364             :         {
    3365             :                 const char *test_str;
    3366             :                 const char *talloc_str;
    3367           0 :                 PyObject *unicode = NULL;
    3368           0 :                 if (PyUnicode_Check(value)) {
    3369           0 :                         unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    3370           0 :                         if (unicode == NULL) {
    3371           0 :                                 return -1;
    3372             :                         }
    3373           0 :                         test_str = PyBytes_AS_STRING(unicode);
    3374           0 :                 } else if (PyBytes_Check(value)) {
    3375           0 :                         test_str = PyBytes_AS_STRING(value);
    3376             :                 } else {
    3377           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    3378           0 :                         return -1;
    3379             :                 }
    3380           0 :                 talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    3381           0 :                 if (unicode != NULL) {
    3382           0 :                         Py_DECREF(unicode);
    3383             :                 }
    3384           0 :                 if (talloc_str == NULL) {
    3385           0 :                         PyErr_NoMemory();
    3386           0 :                         return -1;
    3387             :                 }
    3388           0 :                 object->in.my_accountname = talloc_str;
    3389             :         }
    3390           0 :         return 0;
    3391             : }
    3392             : 
    3393           0 : static PyObject *py_nbtd_getdcname_in_get_account_control(PyObject *obj, void *closure)
    3394             : {
    3395           0 :         struct nbtd_getdcname *object = pytalloc_get_ptr(obj);
    3396             :         PyObject *py_account_control;
    3397           0 :         py_account_control = PyLong_FromUnsignedLongLong((uint32_t)(object->in.account_control));
    3398           0 :         return py_account_control;
    3399             : }
    3400             : 
    3401           0 : static int py_nbtd_getdcname_in_set_account_control(PyObject *py_obj, PyObject *value, void *closure)
    3402             : {
    3403           0 :         struct nbtd_getdcname *object = pytalloc_get_ptr(py_obj);
    3404           0 :         if (value == NULL) {
    3405           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.account_control");
    3406           0 :                 return -1;
    3407             :         }
    3408             :         {
    3409           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.account_control));
    3410           0 :                 if (PyLong_Check(value)) {
    3411             :                         unsigned long long test_var;
    3412           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    3413           0 :                         if (PyErr_Occurred() != NULL) {
    3414           0 :                                 return -1;
    3415             :                         }
    3416           0 :                         if (test_var > uint_max) {
    3417           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3418             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3419           0 :                                 return -1;
    3420             :                         }
    3421           0 :                         object->in.account_control = test_var;
    3422             :                 } else {
    3423           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3424             :                           PyLong_Type.tp_name);
    3425           0 :                         return -1;
    3426             :                 }
    3427             :         }
    3428           0 :         return 0;
    3429             : }
    3430             : 
    3431           0 : static PyObject *py_nbtd_getdcname_in_get_domain_sid(PyObject *obj, void *closure)
    3432             : {
    3433           0 :         struct nbtd_getdcname *object = pytalloc_get_ptr(obj);
    3434             :         PyObject *py_domain_sid;
    3435           0 :         if (object->in.domain_sid == NULL) {
    3436           0 :                 Py_RETURN_NONE;
    3437             :         }
    3438           0 :         py_domain_sid = pytalloc_reference_ex(dom_sid_Type, object->in.domain_sid, object->in.domain_sid);
    3439           0 :         return py_domain_sid;
    3440             : }
    3441             : 
    3442           0 : static int py_nbtd_getdcname_in_set_domain_sid(PyObject *py_obj, PyObject *value, void *closure)
    3443             : {
    3444           0 :         struct nbtd_getdcname *object = pytalloc_get_ptr(py_obj);
    3445           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.domain_sid));
    3446           0 :         if (value == NULL) {
    3447           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.domain_sid");
    3448           0 :                 return -1;
    3449             :         }
    3450           0 :         object->in.domain_sid = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.domain_sid);
    3451           0 :         if (object->in.domain_sid == NULL) {
    3452           0 :                 PyErr_NoMemory();
    3453           0 :                 return -1;
    3454             :         }
    3455           0 :         PY_CHECK_TYPE(dom_sid_Type, value, return -1;);
    3456           0 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    3457           0 :                 PyErr_NoMemory();
    3458           0 :                 return -1;
    3459             :         }
    3460           0 :         object->in.domain_sid = (struct dom_sid *)pytalloc_get_ptr(value);
    3461           0 :         return 0;
    3462             : }
    3463             : 
    3464           0 : static PyObject *py_nbtd_getdcname_out_get_dcname(PyObject *obj, void *closure)
    3465             : {
    3466           0 :         struct nbtd_getdcname *object = pytalloc_get_ptr(obj);
    3467             :         PyObject *py_dcname;
    3468           0 :         if (object->out.dcname == NULL) {
    3469           0 :                 Py_RETURN_NONE;
    3470             :         }
    3471           0 :         if (object->out.dcname == NULL) {
    3472           0 :                 py_dcname = Py_None;
    3473           0 :                 Py_INCREF(py_dcname);
    3474             :         } else {
    3475           0 :                 py_dcname = PyString_FromStringOrNULL(object->out.dcname);
    3476             :         }
    3477           0 :         return py_dcname;
    3478             : }
    3479             : 
    3480           0 : static int py_nbtd_getdcname_out_set_dcname(PyObject *py_obj, PyObject *value, void *closure)
    3481             : {
    3482           0 :         struct nbtd_getdcname *object = pytalloc_get_ptr(py_obj);
    3483           0 :         if (value == NULL) {
    3484           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.dcname");
    3485           0 :                 return -1;
    3486             :         }
    3487           0 :         if (value == Py_None) {
    3488           0 :                 object->out.dcname = NULL;
    3489             :         } else {
    3490           0 :                 object->out.dcname = NULL;
    3491             :                 {
    3492             :                         const char *test_str;
    3493             :                         const char *talloc_str;
    3494           0 :                         PyObject *unicode = NULL;
    3495           0 :                         if (PyUnicode_Check(value)) {
    3496           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    3497           0 :                                 if (unicode == NULL) {
    3498           0 :                                         return -1;
    3499             :                                 }
    3500           0 :                                 test_str = PyBytes_AS_STRING(unicode);
    3501           0 :                         } else if (PyBytes_Check(value)) {
    3502           0 :                                 test_str = PyBytes_AS_STRING(value);
    3503             :                         } else {
    3504           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    3505           0 :                                 return -1;
    3506             :                         }
    3507           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    3508           0 :                         if (unicode != NULL) {
    3509           0 :                                 Py_DECREF(unicode);
    3510             :                         }
    3511           0 :                         if (talloc_str == NULL) {
    3512           0 :                                 PyErr_NoMemory();
    3513           0 :                                 return -1;
    3514             :                         }
    3515           0 :                         object->out.dcname = talloc_str;
    3516             :                 }
    3517             :         }
    3518           0 :         return 0;
    3519             : }
    3520             : 
    3521             : static PyGetSetDef py_nbtd_getdcname_getsetters[] = {
    3522             :         {
    3523             :                 .name = discard_const_p(char, "in_domainname"),
    3524             :                 .get = py_nbtd_getdcname_in_get_domainname,
    3525             :                 .set = py_nbtd_getdcname_in_set_domainname,
    3526             :                 .doc = discard_const_p(char, "PIDL-generated element of base type string")
    3527             :         },
    3528             :         {
    3529             :                 .name = discard_const_p(char, "in_ip_address"),
    3530             :                 .get = py_nbtd_getdcname_in_get_ip_address,
    3531             :                 .set = py_nbtd_getdcname_in_set_ip_address,
    3532             :                 .doc = discard_const_p(char, "PIDL-generated element of base type string")
    3533             :         },
    3534             :         {
    3535             :                 .name = discard_const_p(char, "in_my_computername"),
    3536             :                 .get = py_nbtd_getdcname_in_get_my_computername,
    3537             :                 .set = py_nbtd_getdcname_in_set_my_computername,
    3538             :                 .doc = discard_const_p(char, "PIDL-generated element of base type string")
    3539             :         },
    3540             :         {
    3541             :                 .name = discard_const_p(char, "in_my_accountname"),
    3542             :                 .get = py_nbtd_getdcname_in_get_my_accountname,
    3543             :                 .set = py_nbtd_getdcname_in_set_my_accountname,
    3544             :                 .doc = discard_const_p(char, "PIDL-generated element of base type string")
    3545             :         },
    3546             :         {
    3547             :                 .name = discard_const_p(char, "in_account_control"),
    3548             :                 .get = py_nbtd_getdcname_in_get_account_control,
    3549             :                 .set = py_nbtd_getdcname_in_set_account_control,
    3550             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    3551             :         },
    3552             :         {
    3553             :                 .name = discard_const_p(char, "in_domain_sid"),
    3554             :                 .get = py_nbtd_getdcname_in_get_domain_sid,
    3555             :                 .set = py_nbtd_getdcname_in_set_domain_sid,
    3556             :                 .doc = discard_const_p(char, "PIDL-generated element of base type dom_sid")
    3557             :         },
    3558             :         {
    3559             :                 .name = discard_const_p(char, "out_dcname"),
    3560             :                 .get = py_nbtd_getdcname_out_get_dcname,
    3561             :                 .set = py_nbtd_getdcname_out_set_dcname,
    3562             :                 .doc = discard_const_p(char, "PIDL-generated element of base type string")
    3563             :         },
    3564             :         { .name = NULL }
    3565             : };
    3566             : 
    3567           0 : static PyObject *py_nbtd_getdcname_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    3568             : {
    3569           0 :         PyObject *self = pytalloc_new(struct nbtd_getdcname, type);
    3570           0 :         struct nbtd_getdcname *_self = (struct nbtd_getdcname *)pytalloc_get_ptr(self);
    3571           0 :         TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
    3572           0 :         _self->in.domain_sid = talloc_zero(mem_ctx, struct dom_sid);
    3573           0 :         return self;
    3574             : }
    3575             : 
    3576           0 : static PyObject *py_nbtd_getdcname_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
    3577             : {
    3578             : 
    3579             : 
    3580           0 :         return PyLong_FromLong(2);
    3581             : }
    3582             : 
    3583           0 : static PyObject *py_nbtd_getdcname_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
    3584             : {
    3585           0 :         const struct ndr_interface_call *call = NULL;
    3586           0 :         struct nbtd_getdcname *object = pytalloc_get_ptr(py_obj);
    3587           0 :         PyObject *ret = NULL;
    3588           0 :         struct ndr_push *push = NULL;
    3589             :         DATA_BLOB blob;
    3590             :         enum ndr_err_code err;
    3591             : 
    3592           0 :         if (ndr_table_irpc.num_calls < 3) {
    3593           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_nbtd_getdcname_ndr_pack");
    3594           0 :                 return NULL;
    3595             :         }
    3596           0 :         call = &ndr_table_irpc.calls[2];
    3597             : 
    3598           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
    3599           0 :         if (push == NULL) {
    3600           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    3601           0 :                 return NULL;
    3602             :         }
    3603             : 
    3604           0 :         push->flags |= ndr_push_flags;
    3605             : 
    3606           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
    3607           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    3608           0 :                 TALLOC_FREE(push);
    3609           0 :                 PyErr_SetNdrError(err);
    3610           0 :                 return NULL;
    3611             :         }
    3612           0 :         blob = ndr_push_blob(push);
    3613           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
    3614           0 :         TALLOC_FREE(push);
    3615           0 :         return ret;
    3616             : }
    3617             : 
    3618           0 : static PyObject *py_nbtd_getdcname_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    3619             : {
    3620           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    3621           0 :         PyObject *bigendian_obj = NULL;
    3622           0 :         PyObject *ndr64_obj = NULL;
    3623           0 :         libndr_flags ndr_push_flags = 0;
    3624             : 
    3625           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
    3626             :                 discard_const_p(char *, kwnames),
    3627             :                 &bigendian_obj,
    3628             :                 &ndr64_obj)) {
    3629           0 :                 return NULL;
    3630             :         }
    3631             : 
    3632           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    3633           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    3634             :         }
    3635           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    3636           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    3637             :         }
    3638             : 
    3639           0 :         return py_nbtd_getdcname_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
    3640             : }
    3641             : 
    3642           0 : static PyObject *py_nbtd_getdcname_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    3643             : {
    3644           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    3645           0 :         PyObject *bigendian_obj = NULL;
    3646           0 :         PyObject *ndr64_obj = NULL;
    3647           0 :         libndr_flags ndr_push_flags = 0;
    3648             : 
    3649           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
    3650             :                 discard_const_p(char *, kwnames),
    3651             :                 &bigendian_obj,
    3652             :                 &ndr64_obj)) {
    3653           0 :                 return NULL;
    3654             :         }
    3655             : 
    3656           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    3657           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    3658             :         }
    3659           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    3660           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    3661             :         }
    3662             : 
    3663           0 :         return py_nbtd_getdcname_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
    3664             : }
    3665             : 
    3666           0 : static PyObject *py_nbtd_getdcname_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
    3667             : {
    3668           0 :         const struct ndr_interface_call *call = NULL;
    3669           0 :         struct nbtd_getdcname *object = pytalloc_get_ptr(py_obj);
    3670           0 :         struct ndr_pull *pull = NULL;
    3671             :         enum ndr_err_code err;
    3672             : 
    3673           0 :         if (ndr_table_irpc.num_calls < 3) {
    3674           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_nbtd_getdcname_ndr_unpack");
    3675           0 :                 return NULL;
    3676             :         }
    3677           0 :         call = &ndr_table_irpc.calls[2];
    3678             : 
    3679           0 :         pull = ndr_pull_init_blob(blob, object);
    3680           0 :         if (pull == NULL) {
    3681           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    3682           0 :                 return NULL;
    3683             :         }
    3684             : 
    3685           0 :         pull->flags |= ndr_pull_flags;
    3686             : 
    3687           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
    3688           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    3689           0 :                 TALLOC_FREE(pull);
    3690           0 :                 PyErr_SetNdrError(err);
    3691           0 :                 return NULL;
    3692             :         }
    3693           0 :         if (!allow_remaining) {
    3694             :                 uint32_t highest_ofs;
    3695             : 
    3696           0 :                 if (pull->offset > pull->relative_highest_offset) {
    3697           0 :                         highest_ofs = pull->offset;
    3698             :                 } else {
    3699           0 :                         highest_ofs = pull->relative_highest_offset;
    3700             :                 }
    3701           0 :                 if (highest_ofs < pull->data_size) {
    3702           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
    3703             :                                 "not all bytes consumed ofs[%u] size[%u]",
    3704             :                                 highest_ofs, pull->data_size);
    3705           0 :                         TALLOC_FREE(pull);
    3706           0 :                         PyErr_SetNdrError(err);
    3707           0 :                         return NULL;
    3708             :                 }
    3709             :         }
    3710             : 
    3711           0 :         TALLOC_FREE(pull);
    3712           0 :         Py_RETURN_NONE;
    3713             : }
    3714             : 
    3715           0 : static PyObject *py_nbtd_getdcname_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    3716             : {
    3717             :         DATA_BLOB blob;
    3718           0 :         Py_ssize_t blob_length = 0;
    3719           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    3720           0 :         PyObject *bigendian_obj = NULL;
    3721           0 :         PyObject *ndr64_obj = NULL;
    3722           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    3723           0 :         PyObject *allow_remaining_obj = NULL;
    3724           0 :         bool allow_remaining = false;
    3725             : 
    3726           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
    3727             :                 discard_const_p(char *, kwnames),
    3728             :                 &blob.data, &blob_length,
    3729             :                 &bigendian_obj,
    3730             :                 &ndr64_obj,
    3731             :                 &allow_remaining_obj)) {
    3732           0 :                 return NULL;
    3733             :         }
    3734           0 :         blob.length = blob_length;
    3735             : 
    3736           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    3737           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    3738             :         }
    3739           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    3740           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    3741             :         }
    3742             : 
    3743           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    3744           0 :                 allow_remaining = true;
    3745             :         }
    3746             : 
    3747           0 :         return py_nbtd_getdcname_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
    3748             : }
    3749             : 
    3750           0 : static PyObject *py_nbtd_getdcname_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    3751             : {
    3752             :         DATA_BLOB blob;
    3753           0 :         Py_ssize_t blob_length = 0;
    3754           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    3755           0 :         PyObject *bigendian_obj = NULL;
    3756           0 :         PyObject *ndr64_obj = NULL;
    3757           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    3758           0 :         PyObject *allow_remaining_obj = NULL;
    3759           0 :         bool allow_remaining = false;
    3760             : 
    3761           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
    3762             :                 discard_const_p(char *, kwnames),
    3763             :                 &blob.data, &blob_length,
    3764             :                 &bigendian_obj,
    3765             :                 &ndr64_obj,
    3766             :                 &allow_remaining_obj)) {
    3767           0 :                 return NULL;
    3768             :         }
    3769           0 :         blob.length = blob_length;
    3770             : 
    3771           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    3772           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    3773             :         }
    3774           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    3775           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    3776             :         }
    3777             : 
    3778           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    3779           0 :                 allow_remaining = true;
    3780             :         }
    3781             : 
    3782           0 :         return py_nbtd_getdcname_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
    3783             : }
    3784             : 
    3785           0 : static PyObject *py_nbtd_getdcname_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
    3786             : {
    3787           0 :         const struct ndr_interface_call *call = NULL;
    3788           0 :         struct nbtd_getdcname *object = pytalloc_get_ptr(py_obj);
    3789             :         PyObject *ret;
    3790             :         char *retstr;
    3791             : 
    3792           0 :         if (ndr_table_irpc.num_calls < 3) {
    3793           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_nbtd_getdcname_ndr_print");
    3794           0 :                 return NULL;
    3795             :         }
    3796           0 :         call = &ndr_table_irpc.calls[2];
    3797             : 
    3798           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
    3799           0 :         ret = PyUnicode_FromString(retstr);
    3800           0 :         TALLOC_FREE(retstr);
    3801             : 
    3802           0 :         return ret;
    3803             : }
    3804             : 
    3805           0 : static PyObject *py_nbtd_getdcname_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    3806             : {
    3807           0 :         return py_nbtd_getdcname_ndr_print(py_obj, "nbtd_getdcname_in", NDR_IN);
    3808             : }
    3809             : 
    3810           0 : static PyObject *py_nbtd_getdcname_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    3811             : {
    3812           0 :         return py_nbtd_getdcname_ndr_print(py_obj, "nbtd_getdcname_out", NDR_OUT);
    3813             : }
    3814             : 
    3815             : static PyMethodDef py_nbtd_getdcname_methods[] = {
    3816             :         { "opnum", (PyCFunction)py_nbtd_getdcname_ndr_opnum, METH_NOARGS|METH_CLASS,
    3817             :                 "irpc.nbtd_getdcname.opnum() -> 2 (0x02) " },
    3818             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_nbtd_getdcname_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
    3819             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
    3820             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_nbtd_getdcname_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
    3821             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
    3822             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_nbtd_getdcname_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
    3823             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
    3824             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_nbtd_getdcname_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
    3825             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
    3826             :         { "__ndr_print_in__", (PyCFunction)py_nbtd_getdcname_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
    3827             :         { "__ndr_print_out__", (PyCFunction)py_nbtd_getdcname_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
    3828             :         { NULL, NULL, 0, NULL }
    3829             : };
    3830             : 
    3831             : 
    3832             : static PyTypeObject nbtd_getdcname_Type = {
    3833             :         PyVarObject_HEAD_INIT(NULL, 0)
    3834             :         .tp_name = "irpc.nbtd_getdcname",
    3835             :         .tp_getset = py_nbtd_getdcname_getsetters,
    3836             :         .tp_methods = py_nbtd_getdcname_methods,
    3837             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    3838             :         .tp_new = py_nbtd_getdcname_new,
    3839             : };
    3840             : 
    3841           0 : static bool pack_py_nbtd_getdcname_args_in(PyObject *args, PyObject *kwargs, struct nbtd_getdcname *r)
    3842             : {
    3843             :         PyObject *py_domainname;
    3844             :         PyObject *py_ip_address;
    3845             :         PyObject *py_my_computername;
    3846             :         PyObject *py_my_accountname;
    3847             :         PyObject *py_account_control;
    3848             :         PyObject *py_domain_sid;
    3849           0 :         const char *kwnames[] = {
    3850             :                 "domainname", "ip_address", "my_computername", "my_accountname", "account_control", "domain_sid", NULL
    3851             :         };
    3852             : 
    3853           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:nbtd_getdcname", discard_const_p(char *, kwnames), &py_domainname, &py_ip_address, &py_my_computername, &py_my_accountname, &py_account_control, &py_domain_sid)) {
    3854           0 :                 return false;
    3855             :         }
    3856             : 
    3857           0 :         if (py_domainname == NULL) {
    3858           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.domainname");
    3859           0 :                 return false;
    3860             :         }
    3861             :         {
    3862             :                 const char *test_str;
    3863             :                 const char *talloc_str;
    3864           0 :                 PyObject *unicode = NULL;
    3865           0 :                 if (PyUnicode_Check(py_domainname)) {
    3866           0 :                         unicode = PyUnicode_AsEncodedString(py_domainname, "utf-8", "ignore");
    3867           0 :                         if (unicode == NULL) {
    3868           0 :                                 return false;
    3869             :                         }
    3870           0 :                         test_str = PyBytes_AS_STRING(unicode);
    3871           0 :                 } else if (PyBytes_Check(py_domainname)) {
    3872           0 :                         test_str = PyBytes_AS_STRING(py_domainname);
    3873             :                 } else {
    3874           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_domainname)->tp_name);
    3875           0 :                         return false;
    3876             :                 }
    3877           0 :                 talloc_str = talloc_strdup(r, test_str);
    3878           0 :                 if (unicode != NULL) {
    3879           0 :                         Py_DECREF(unicode);
    3880             :                 }
    3881           0 :                 if (talloc_str == NULL) {
    3882           0 :                         PyErr_NoMemory();
    3883           0 :                         return false;
    3884             :                 }
    3885           0 :                 r->in.domainname = talloc_str;
    3886             :         }
    3887           0 :         if (py_ip_address == NULL) {
    3888           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.ip_address");
    3889           0 :                 return false;
    3890             :         }
    3891             :         {
    3892             :                 const char *test_str;
    3893             :                 const char *talloc_str;
    3894           0 :                 PyObject *unicode = NULL;
    3895           0 :                 if (PyUnicode_Check(py_ip_address)) {
    3896           0 :                         unicode = PyUnicode_AsEncodedString(py_ip_address, "utf-8", "ignore");
    3897           0 :                         if (unicode == NULL) {
    3898           0 :                                 return false;
    3899             :                         }
    3900           0 :                         test_str = PyBytes_AS_STRING(unicode);
    3901           0 :                 } else if (PyBytes_Check(py_ip_address)) {
    3902           0 :                         test_str = PyBytes_AS_STRING(py_ip_address);
    3903             :                 } else {
    3904           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_ip_address)->tp_name);
    3905           0 :                         return false;
    3906             :                 }
    3907           0 :                 talloc_str = talloc_strdup(r, test_str);
    3908           0 :                 if (unicode != NULL) {
    3909           0 :                         Py_DECREF(unicode);
    3910             :                 }
    3911           0 :                 if (talloc_str == NULL) {
    3912           0 :                         PyErr_NoMemory();
    3913           0 :                         return false;
    3914             :                 }
    3915           0 :                 r->in.ip_address = talloc_str;
    3916             :         }
    3917           0 :         if (py_my_computername == NULL) {
    3918           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.my_computername");
    3919           0 :                 return false;
    3920             :         }
    3921             :         {
    3922             :                 const char *test_str;
    3923             :                 const char *talloc_str;
    3924           0 :                 PyObject *unicode = NULL;
    3925           0 :                 if (PyUnicode_Check(py_my_computername)) {
    3926           0 :                         unicode = PyUnicode_AsEncodedString(py_my_computername, "utf-8", "ignore");
    3927           0 :                         if (unicode == NULL) {
    3928           0 :                                 return false;
    3929             :                         }
    3930           0 :                         test_str = PyBytes_AS_STRING(unicode);
    3931           0 :                 } else if (PyBytes_Check(py_my_computername)) {
    3932           0 :                         test_str = PyBytes_AS_STRING(py_my_computername);
    3933             :                 } else {
    3934           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_my_computername)->tp_name);
    3935           0 :                         return false;
    3936             :                 }
    3937           0 :                 talloc_str = talloc_strdup(r, test_str);
    3938           0 :                 if (unicode != NULL) {
    3939           0 :                         Py_DECREF(unicode);
    3940             :                 }
    3941           0 :                 if (talloc_str == NULL) {
    3942           0 :                         PyErr_NoMemory();
    3943           0 :                         return false;
    3944             :                 }
    3945           0 :                 r->in.my_computername = talloc_str;
    3946             :         }
    3947           0 :         if (py_my_accountname == NULL) {
    3948           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.my_accountname");
    3949           0 :                 return false;
    3950             :         }
    3951             :         {
    3952             :                 const char *test_str;
    3953             :                 const char *talloc_str;
    3954           0 :                 PyObject *unicode = NULL;
    3955           0 :                 if (PyUnicode_Check(py_my_accountname)) {
    3956           0 :                         unicode = PyUnicode_AsEncodedString(py_my_accountname, "utf-8", "ignore");
    3957           0 :                         if (unicode == NULL) {
    3958           0 :                                 return false;
    3959             :                         }
    3960           0 :                         test_str = PyBytes_AS_STRING(unicode);
    3961           0 :                 } else if (PyBytes_Check(py_my_accountname)) {
    3962           0 :                         test_str = PyBytes_AS_STRING(py_my_accountname);
    3963             :                 } else {
    3964           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_my_accountname)->tp_name);
    3965           0 :                         return false;
    3966             :                 }
    3967           0 :                 talloc_str = talloc_strdup(r, test_str);
    3968           0 :                 if (unicode != NULL) {
    3969           0 :                         Py_DECREF(unicode);
    3970             :                 }
    3971           0 :                 if (talloc_str == NULL) {
    3972           0 :                         PyErr_NoMemory();
    3973           0 :                         return false;
    3974             :                 }
    3975           0 :                 r->in.my_accountname = talloc_str;
    3976             :         }
    3977           0 :         if (py_account_control == NULL) {
    3978           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.account_control");
    3979           0 :                 return false;
    3980             :         }
    3981             :         {
    3982           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.account_control));
    3983           0 :                 if (PyLong_Check(py_account_control)) {
    3984             :                         unsigned long long test_var;
    3985           0 :                         test_var = PyLong_AsUnsignedLongLong(py_account_control);
    3986           0 :                         if (PyErr_Occurred() != NULL) {
    3987           0 :                                 return false;
    3988             :                         }
    3989           0 :                         if (test_var > uint_max) {
    3990           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3991             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3992           0 :                                 return false;
    3993             :                         }
    3994           0 :                         r->in.account_control = test_var;
    3995             :                 } else {
    3996           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3997             :                           PyLong_Type.tp_name);
    3998           0 :                         return false;
    3999             :                 }
    4000             :         }
    4001           0 :         if (py_domain_sid == NULL) {
    4002           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.domain_sid");
    4003           0 :                 return false;
    4004             :         }
    4005           0 :         r->in.domain_sid = talloc_ptrtype(r, r->in.domain_sid);
    4006           0 :         if (r->in.domain_sid == NULL) {
    4007           0 :                 PyErr_NoMemory();
    4008           0 :                 return false;
    4009             :         }
    4010           0 :         PY_CHECK_TYPE(dom_sid_Type, py_domain_sid, return false;);
    4011           0 :         if (talloc_reference(r, pytalloc_get_mem_ctx(py_domain_sid)) == NULL) {
    4012           0 :                 PyErr_NoMemory();
    4013           0 :                 return false;
    4014             :         }
    4015           0 :         r->in.domain_sid = (struct dom_sid *)pytalloc_get_ptr(py_domain_sid);
    4016           0 :         return true;
    4017             : }
    4018             : 
    4019           0 : static PyObject *unpack_py_nbtd_getdcname_args_out(struct nbtd_getdcname *r)
    4020             : {
    4021             :         PyObject *result;
    4022             :         PyObject *py_dcname;
    4023           0 :         if (r->out.dcname == NULL) {
    4024           0 :                 py_dcname = Py_None;
    4025           0 :                 Py_INCREF(py_dcname);
    4026             :         } else {
    4027           0 :                 py_dcname = PyString_FromStringOrNULL(r->out.dcname);
    4028             :         }
    4029           0 :         result = py_dcname;
    4030           0 :         return result;
    4031             : }
    4032             : 
    4033             : 
    4034           0 : static PyObject *py_nbtd_proxy_wins_challenge_in_get_name(PyObject *obj, void *closure)
    4035             : {
    4036           0 :         struct nbtd_proxy_wins_challenge *object = pytalloc_get_ptr(obj);
    4037             :         PyObject *py_name;
    4038           0 :         py_name = pytalloc_reference_ex(nbt_name_Type, pytalloc_get_mem_ctx(obj), &object->in.name);
    4039           0 :         return py_name;
    4040             : }
    4041             : 
    4042           0 : static int py_nbtd_proxy_wins_challenge_in_set_name(PyObject *py_obj, PyObject *value, void *closure)
    4043             : {
    4044           0 :         struct nbtd_proxy_wins_challenge *object = pytalloc_get_ptr(py_obj);
    4045           0 :         if (value == NULL) {
    4046           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.name");
    4047           0 :                 return -1;
    4048             :         }
    4049           0 :         PY_CHECK_TYPE(nbt_name_Type, value, return -1;);
    4050           0 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    4051           0 :                 PyErr_NoMemory();
    4052           0 :                 return -1;
    4053             :         }
    4054           0 :         object->in.name = *(struct nbt_name *)pytalloc_get_ptr(value);
    4055           0 :         return 0;
    4056             : }
    4057             : 
    4058           0 : static PyObject *py_nbtd_proxy_wins_challenge_in_get_num_addrs(PyObject *obj, void *closure)
    4059             : {
    4060           0 :         struct nbtd_proxy_wins_challenge *object = pytalloc_get_ptr(obj);
    4061             :         PyObject *py_num_addrs;
    4062           0 :         py_num_addrs = PyLong_FromUnsignedLongLong((uint32_t)(object->in.num_addrs));
    4063           0 :         return py_num_addrs;
    4064             : }
    4065             : 
    4066           0 : static int py_nbtd_proxy_wins_challenge_in_set_num_addrs(PyObject *py_obj, PyObject *value, void *closure)
    4067             : {
    4068           0 :         struct nbtd_proxy_wins_challenge *object = pytalloc_get_ptr(py_obj);
    4069           0 :         if (value == NULL) {
    4070           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.num_addrs");
    4071           0 :                 return -1;
    4072             :         }
    4073             :         {
    4074           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.num_addrs));
    4075           0 :                 if (PyLong_Check(value)) {
    4076             :                         unsigned long long test_var;
    4077           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    4078           0 :                         if (PyErr_Occurred() != NULL) {
    4079           0 :                                 return -1;
    4080             :                         }
    4081           0 :                         if (test_var > uint_max) {
    4082           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4083             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4084           0 :                                 return -1;
    4085             :                         }
    4086           0 :                         object->in.num_addrs = test_var;
    4087             :                 } else {
    4088           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4089             :                           PyLong_Type.tp_name);
    4090           0 :                         return -1;
    4091             :                 }
    4092             :         }
    4093           0 :         return 0;
    4094             : }
    4095             : 
    4096           0 : static PyObject *py_nbtd_proxy_wins_challenge_out_get_num_addrs(PyObject *obj, void *closure)
    4097             : {
    4098           0 :         struct nbtd_proxy_wins_challenge *object = pytalloc_get_ptr(obj);
    4099             :         PyObject *py_num_addrs;
    4100           0 :         py_num_addrs = PyLong_FromUnsignedLongLong((uint32_t)(object->out.num_addrs));
    4101           0 :         return py_num_addrs;
    4102             : }
    4103             : 
    4104           0 : static int py_nbtd_proxy_wins_challenge_out_set_num_addrs(PyObject *py_obj, PyObject *value, void *closure)
    4105             : {
    4106           0 :         struct nbtd_proxy_wins_challenge *object = pytalloc_get_ptr(py_obj);
    4107           0 :         if (value == NULL) {
    4108           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.num_addrs");
    4109           0 :                 return -1;
    4110             :         }
    4111             :         {
    4112           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->out.num_addrs));
    4113           0 :                 if (PyLong_Check(value)) {
    4114             :                         unsigned long long test_var;
    4115           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    4116           0 :                         if (PyErr_Occurred() != NULL) {
    4117           0 :                                 return -1;
    4118             :                         }
    4119           0 :                         if (test_var > uint_max) {
    4120           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4121             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4122           0 :                                 return -1;
    4123             :                         }
    4124           0 :                         object->out.num_addrs = test_var;
    4125             :                 } else {
    4126           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4127             :                           PyLong_Type.tp_name);
    4128           0 :                         return -1;
    4129             :                 }
    4130             :         }
    4131           0 :         return 0;
    4132             : }
    4133             : 
    4134           0 : static PyObject *py_nbtd_proxy_wins_challenge_in_get_addrs(PyObject *obj, void *closure)
    4135             : {
    4136           0 :         struct nbtd_proxy_wins_challenge *object = pytalloc_get_ptr(obj);
    4137             :         PyObject *py_addrs;
    4138           0 :         py_addrs = PyList_New(object->in.num_addrs);
    4139           0 :         if (py_addrs == NULL) {
    4140           0 :                 return NULL;
    4141             :         }
    4142             :         {
    4143             :                 int addrs_cntr_0;
    4144           0 :                 for (addrs_cntr_0 = 0; addrs_cntr_0 < (object->in.num_addrs); addrs_cntr_0++) {
    4145             :                         PyObject *py_addrs_0;
    4146           0 :                         py_addrs_0 = pytalloc_reference_ex(&nbtd_proxy_wins_addr_Type, object->in.addrs, &(object->in.addrs)[addrs_cntr_0]);
    4147           0 :                         PyList_SetItem(py_addrs, addrs_cntr_0, py_addrs_0);
    4148             :                 }
    4149             :         }
    4150           0 :         return py_addrs;
    4151             : }
    4152             : 
    4153           0 : static int py_nbtd_proxy_wins_challenge_in_set_addrs(PyObject *py_obj, PyObject *value, void *closure)
    4154             : {
    4155           0 :         struct nbtd_proxy_wins_challenge *object = pytalloc_get_ptr(py_obj);
    4156           0 :         if (value == NULL) {
    4157           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.addrs");
    4158           0 :                 return -1;
    4159             :         }
    4160           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
    4161             :         {
    4162             :                 int addrs_cntr_0;
    4163           0 :                 object->in.addrs = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.addrs, PyList_GET_SIZE(value));
    4164           0 :                 if (!object->in.addrs) { return -1; }
    4165           0 :                 talloc_set_name_const(object->in.addrs, "ARRAY: object->in.addrs");
    4166           0 :                 for (addrs_cntr_0 = 0; addrs_cntr_0 < PyList_GET_SIZE(value); addrs_cntr_0++) {
    4167           0 :                         if (PyList_GET_ITEM(value, addrs_cntr_0) == NULL) {
    4168           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->in.addrs)[addrs_cntr_0]");
    4169           0 :                                 return -1;
    4170             :                         }
    4171           0 :                         PY_CHECK_TYPE(&nbtd_proxy_wins_addr_Type, PyList_GET_ITEM(value, addrs_cntr_0), return -1;);
    4172           0 :                         if (talloc_reference(object->in.addrs, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, addrs_cntr_0))) == NULL) {
    4173           0 :                                 PyErr_NoMemory();
    4174           0 :                                 return -1;
    4175             :                         }
    4176           0 :                         (object->in.addrs)[addrs_cntr_0] = *(struct nbtd_proxy_wins_addr *)pytalloc_get_ptr(PyList_GET_ITEM(value, addrs_cntr_0));
    4177             :                 }
    4178             :         }
    4179           0 :         return 0;
    4180             : }
    4181             : 
    4182           0 : static PyObject *py_nbtd_proxy_wins_challenge_out_get_addrs(PyObject *obj, void *closure)
    4183             : {
    4184           0 :         struct nbtd_proxy_wins_challenge *object = pytalloc_get_ptr(obj);
    4185             :         PyObject *py_addrs;
    4186           0 :         py_addrs = PyList_New(object->out.num_addrs);
    4187           0 :         if (py_addrs == NULL) {
    4188           0 :                 return NULL;
    4189             :         }
    4190             :         {
    4191             :                 int addrs_cntr_0;
    4192           0 :                 for (addrs_cntr_0 = 0; addrs_cntr_0 < (object->out.num_addrs); addrs_cntr_0++) {
    4193             :                         PyObject *py_addrs_0;
    4194           0 :                         py_addrs_0 = pytalloc_reference_ex(&nbtd_proxy_wins_addr_Type, object->out.addrs, &(object->out.addrs)[addrs_cntr_0]);
    4195           0 :                         PyList_SetItem(py_addrs, addrs_cntr_0, py_addrs_0);
    4196             :                 }
    4197             :         }
    4198           0 :         return py_addrs;
    4199             : }
    4200             : 
    4201           0 : static int py_nbtd_proxy_wins_challenge_out_set_addrs(PyObject *py_obj, PyObject *value, void *closure)
    4202             : {
    4203           0 :         struct nbtd_proxy_wins_challenge *object = pytalloc_get_ptr(py_obj);
    4204           0 :         if (value == NULL) {
    4205           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.addrs");
    4206           0 :                 return -1;
    4207             :         }
    4208           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
    4209             :         {
    4210             :                 int addrs_cntr_0;
    4211           0 :                 object->out.addrs = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.addrs, PyList_GET_SIZE(value));
    4212           0 :                 if (!object->out.addrs) { return -1; }
    4213           0 :                 talloc_set_name_const(object->out.addrs, "ARRAY: object->out.addrs");
    4214           0 :                 for (addrs_cntr_0 = 0; addrs_cntr_0 < PyList_GET_SIZE(value); addrs_cntr_0++) {
    4215           0 :                         if (PyList_GET_ITEM(value, addrs_cntr_0) == NULL) {
    4216           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->out.addrs)[addrs_cntr_0]");
    4217           0 :                                 return -1;
    4218             :                         }
    4219           0 :                         PY_CHECK_TYPE(&nbtd_proxy_wins_addr_Type, PyList_GET_ITEM(value, addrs_cntr_0), return -1;);
    4220           0 :                         if (talloc_reference(object->out.addrs, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, addrs_cntr_0))) == NULL) {
    4221           0 :                                 PyErr_NoMemory();
    4222           0 :                                 return -1;
    4223             :                         }
    4224           0 :                         (object->out.addrs)[addrs_cntr_0] = *(struct nbtd_proxy_wins_addr *)pytalloc_get_ptr(PyList_GET_ITEM(value, addrs_cntr_0));
    4225             :                 }
    4226             :         }
    4227           0 :         return 0;
    4228             : }
    4229             : 
    4230             : static PyGetSetDef py_nbtd_proxy_wins_challenge_getsetters[] = {
    4231             :         {
    4232             :                 .name = discard_const_p(char, "in_name"),
    4233             :                 .get = py_nbtd_proxy_wins_challenge_in_get_name,
    4234             :                 .set = py_nbtd_proxy_wins_challenge_in_set_name,
    4235             :                 .doc = discard_const_p(char, "PIDL-generated element of base type nbt_name")
    4236             :         },
    4237             :         {
    4238             :                 .name = discard_const_p(char, "in_num_addrs"),
    4239             :                 .get = py_nbtd_proxy_wins_challenge_in_get_num_addrs,
    4240             :                 .set = py_nbtd_proxy_wins_challenge_in_set_num_addrs,
    4241             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    4242             :         },
    4243             :         {
    4244             :                 .name = discard_const_p(char, "out_num_addrs"),
    4245             :                 .get = py_nbtd_proxy_wins_challenge_out_get_num_addrs,
    4246             :                 .set = py_nbtd_proxy_wins_challenge_out_set_num_addrs,
    4247             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    4248             :         },
    4249             :         {
    4250             :                 .name = discard_const_p(char, "in_addrs"),
    4251             :                 .get = py_nbtd_proxy_wins_challenge_in_get_addrs,
    4252             :                 .set = py_nbtd_proxy_wins_challenge_in_set_addrs,
    4253             :                 .doc = discard_const_p(char, "PIDL-generated element of base type nbtd_proxy_wins_addr")
    4254             :         },
    4255             :         {
    4256             :                 .name = discard_const_p(char, "out_addrs"),
    4257             :                 .get = py_nbtd_proxy_wins_challenge_out_get_addrs,
    4258             :                 .set = py_nbtd_proxy_wins_challenge_out_set_addrs,
    4259             :                 .doc = discard_const_p(char, "PIDL-generated element of base type nbtd_proxy_wins_addr")
    4260             :         },
    4261             :         { .name = NULL }
    4262             : };
    4263             : 
    4264           0 : static PyObject *py_nbtd_proxy_wins_challenge_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    4265             : {
    4266           0 :         PyObject *self = pytalloc_new(struct nbtd_proxy_wins_challenge, type);
    4267           0 :         return self;
    4268             : }
    4269             : 
    4270           0 : static PyObject *py_nbtd_proxy_wins_challenge_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
    4271             : {
    4272             : 
    4273             : 
    4274           0 :         return PyLong_FromLong(3);
    4275             : }
    4276             : 
    4277           0 : static PyObject *py_nbtd_proxy_wins_challenge_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
    4278             : {
    4279           0 :         const struct ndr_interface_call *call = NULL;
    4280           0 :         struct nbtd_proxy_wins_challenge *object = pytalloc_get_ptr(py_obj);
    4281           0 :         PyObject *ret = NULL;
    4282           0 :         struct ndr_push *push = NULL;
    4283             :         DATA_BLOB blob;
    4284             :         enum ndr_err_code err;
    4285             : 
    4286           0 :         if (ndr_table_irpc.num_calls < 4) {
    4287           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_nbtd_proxy_wins_challenge_ndr_pack");
    4288           0 :                 return NULL;
    4289             :         }
    4290           0 :         call = &ndr_table_irpc.calls[3];
    4291             : 
    4292           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
    4293           0 :         if (push == NULL) {
    4294           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    4295           0 :                 return NULL;
    4296             :         }
    4297             : 
    4298           0 :         push->flags |= ndr_push_flags;
    4299             : 
    4300           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
    4301           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    4302           0 :                 TALLOC_FREE(push);
    4303           0 :                 PyErr_SetNdrError(err);
    4304           0 :                 return NULL;
    4305             :         }
    4306           0 :         blob = ndr_push_blob(push);
    4307           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
    4308           0 :         TALLOC_FREE(push);
    4309           0 :         return ret;
    4310             : }
    4311             : 
    4312           0 : static PyObject *py_nbtd_proxy_wins_challenge_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    4313             : {
    4314           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    4315           0 :         PyObject *bigendian_obj = NULL;
    4316           0 :         PyObject *ndr64_obj = NULL;
    4317           0 :         libndr_flags ndr_push_flags = 0;
    4318             : 
    4319           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
    4320             :                 discard_const_p(char *, kwnames),
    4321             :                 &bigendian_obj,
    4322             :                 &ndr64_obj)) {
    4323           0 :                 return NULL;
    4324             :         }
    4325             : 
    4326           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    4327           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    4328             :         }
    4329           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    4330           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    4331             :         }
    4332             : 
    4333           0 :         return py_nbtd_proxy_wins_challenge_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
    4334             : }
    4335             : 
    4336           0 : static PyObject *py_nbtd_proxy_wins_challenge_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    4337             : {
    4338           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    4339           0 :         PyObject *bigendian_obj = NULL;
    4340           0 :         PyObject *ndr64_obj = NULL;
    4341           0 :         libndr_flags ndr_push_flags = 0;
    4342             : 
    4343           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
    4344             :                 discard_const_p(char *, kwnames),
    4345             :                 &bigendian_obj,
    4346             :                 &ndr64_obj)) {
    4347           0 :                 return NULL;
    4348             :         }
    4349             : 
    4350           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    4351           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    4352             :         }
    4353           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    4354           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    4355             :         }
    4356             : 
    4357           0 :         return py_nbtd_proxy_wins_challenge_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
    4358             : }
    4359             : 
    4360           0 : static PyObject *py_nbtd_proxy_wins_challenge_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
    4361             : {
    4362           0 :         const struct ndr_interface_call *call = NULL;
    4363           0 :         struct nbtd_proxy_wins_challenge *object = pytalloc_get_ptr(py_obj);
    4364           0 :         struct ndr_pull *pull = NULL;
    4365             :         enum ndr_err_code err;
    4366             : 
    4367           0 :         if (ndr_table_irpc.num_calls < 4) {
    4368           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_nbtd_proxy_wins_challenge_ndr_unpack");
    4369           0 :                 return NULL;
    4370             :         }
    4371           0 :         call = &ndr_table_irpc.calls[3];
    4372             : 
    4373           0 :         pull = ndr_pull_init_blob(blob, object);
    4374           0 :         if (pull == NULL) {
    4375           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    4376           0 :                 return NULL;
    4377             :         }
    4378             : 
    4379           0 :         pull->flags |= ndr_pull_flags;
    4380             : 
    4381           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
    4382           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    4383           0 :                 TALLOC_FREE(pull);
    4384           0 :                 PyErr_SetNdrError(err);
    4385           0 :                 return NULL;
    4386             :         }
    4387           0 :         if (!allow_remaining) {
    4388             :                 uint32_t highest_ofs;
    4389             : 
    4390           0 :                 if (pull->offset > pull->relative_highest_offset) {
    4391           0 :                         highest_ofs = pull->offset;
    4392             :                 } else {
    4393           0 :                         highest_ofs = pull->relative_highest_offset;
    4394             :                 }
    4395           0 :                 if (highest_ofs < pull->data_size) {
    4396           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
    4397             :                                 "not all bytes consumed ofs[%u] size[%u]",
    4398             :                                 highest_ofs, pull->data_size);
    4399           0 :                         TALLOC_FREE(pull);
    4400           0 :                         PyErr_SetNdrError(err);
    4401           0 :                         return NULL;
    4402             :                 }
    4403             :         }
    4404             : 
    4405           0 :         TALLOC_FREE(pull);
    4406           0 :         Py_RETURN_NONE;
    4407             : }
    4408             : 
    4409           0 : static PyObject *py_nbtd_proxy_wins_challenge_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    4410             : {
    4411             :         DATA_BLOB blob;
    4412           0 :         Py_ssize_t blob_length = 0;
    4413           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    4414           0 :         PyObject *bigendian_obj = NULL;
    4415           0 :         PyObject *ndr64_obj = NULL;
    4416           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    4417           0 :         PyObject *allow_remaining_obj = NULL;
    4418           0 :         bool allow_remaining = false;
    4419             : 
    4420           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
    4421             :                 discard_const_p(char *, kwnames),
    4422             :                 &blob.data, &blob_length,
    4423             :                 &bigendian_obj,
    4424             :                 &ndr64_obj,
    4425             :                 &allow_remaining_obj)) {
    4426           0 :                 return NULL;
    4427             :         }
    4428           0 :         blob.length = blob_length;
    4429             : 
    4430           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    4431           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    4432             :         }
    4433           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    4434           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    4435             :         }
    4436             : 
    4437           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    4438           0 :                 allow_remaining = true;
    4439             :         }
    4440             : 
    4441           0 :         return py_nbtd_proxy_wins_challenge_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
    4442             : }
    4443             : 
    4444           0 : static PyObject *py_nbtd_proxy_wins_challenge_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    4445             : {
    4446             :         DATA_BLOB blob;
    4447           0 :         Py_ssize_t blob_length = 0;
    4448           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    4449           0 :         PyObject *bigendian_obj = NULL;
    4450           0 :         PyObject *ndr64_obj = NULL;
    4451           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    4452           0 :         PyObject *allow_remaining_obj = NULL;
    4453           0 :         bool allow_remaining = false;
    4454             : 
    4455           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
    4456             :                 discard_const_p(char *, kwnames),
    4457             :                 &blob.data, &blob_length,
    4458             :                 &bigendian_obj,
    4459             :                 &ndr64_obj,
    4460             :                 &allow_remaining_obj)) {
    4461           0 :                 return NULL;
    4462             :         }
    4463           0 :         blob.length = blob_length;
    4464             : 
    4465           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    4466           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    4467             :         }
    4468           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    4469           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    4470             :         }
    4471             : 
    4472           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    4473           0 :                 allow_remaining = true;
    4474             :         }
    4475             : 
    4476           0 :         return py_nbtd_proxy_wins_challenge_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
    4477             : }
    4478             : 
    4479           0 : static PyObject *py_nbtd_proxy_wins_challenge_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
    4480             : {
    4481           0 :         const struct ndr_interface_call *call = NULL;
    4482           0 :         struct nbtd_proxy_wins_challenge *object = pytalloc_get_ptr(py_obj);
    4483             :         PyObject *ret;
    4484             :         char *retstr;
    4485             : 
    4486           0 :         if (ndr_table_irpc.num_calls < 4) {
    4487           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_nbtd_proxy_wins_challenge_ndr_print");
    4488           0 :                 return NULL;
    4489             :         }
    4490           0 :         call = &ndr_table_irpc.calls[3];
    4491             : 
    4492           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
    4493           0 :         ret = PyUnicode_FromString(retstr);
    4494           0 :         TALLOC_FREE(retstr);
    4495             : 
    4496           0 :         return ret;
    4497             : }
    4498             : 
    4499           0 : static PyObject *py_nbtd_proxy_wins_challenge_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    4500             : {
    4501           0 :         return py_nbtd_proxy_wins_challenge_ndr_print(py_obj, "nbtd_proxy_wins_challenge_in", NDR_IN);
    4502             : }
    4503             : 
    4504           0 : static PyObject *py_nbtd_proxy_wins_challenge_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    4505             : {
    4506           0 :         return py_nbtd_proxy_wins_challenge_ndr_print(py_obj, "nbtd_proxy_wins_challenge_out", NDR_OUT);
    4507             : }
    4508             : 
    4509             : static PyMethodDef py_nbtd_proxy_wins_challenge_methods[] = {
    4510             :         { "opnum", (PyCFunction)py_nbtd_proxy_wins_challenge_ndr_opnum, METH_NOARGS|METH_CLASS,
    4511             :                 "irpc.nbtd_proxy_wins_challenge.opnum() -> 3 (0x03) " },
    4512             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_nbtd_proxy_wins_challenge_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
    4513             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
    4514             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_nbtd_proxy_wins_challenge_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
    4515             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
    4516             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_nbtd_proxy_wins_challenge_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
    4517             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
    4518             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_nbtd_proxy_wins_challenge_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
    4519             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
    4520             :         { "__ndr_print_in__", (PyCFunction)py_nbtd_proxy_wins_challenge_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
    4521             :         { "__ndr_print_out__", (PyCFunction)py_nbtd_proxy_wins_challenge_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
    4522             :         { NULL, NULL, 0, NULL }
    4523             : };
    4524             : 
    4525             : 
    4526             : static PyTypeObject nbtd_proxy_wins_challenge_Type = {
    4527             :         PyVarObject_HEAD_INIT(NULL, 0)
    4528             :         .tp_name = "irpc.nbtd_proxy_wins_challenge",
    4529             :         .tp_getset = py_nbtd_proxy_wins_challenge_getsetters,
    4530             :         .tp_methods = py_nbtd_proxy_wins_challenge_methods,
    4531             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    4532             :         .tp_new = py_nbtd_proxy_wins_challenge_new,
    4533             : };
    4534             : 
    4535           0 : static bool pack_py_nbtd_proxy_wins_challenge_args_in(PyObject *args, PyObject *kwargs, struct nbtd_proxy_wins_challenge *r)
    4536             : {
    4537             :         PyObject *py_name;
    4538             :         PyObject *py_num_addrs;
    4539             :         PyObject *py_addrs;
    4540           0 :         const char *kwnames[] = {
    4541             :                 "name", "num_addrs", "addrs", NULL
    4542             :         };
    4543             : 
    4544           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:nbtd_proxy_wins_challenge", discard_const_p(char *, kwnames), &py_name, &py_num_addrs, &py_addrs)) {
    4545           0 :                 return false;
    4546             :         }
    4547             : 
    4548           0 :         if (py_name == NULL) {
    4549           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.name");
    4550           0 :                 return false;
    4551             :         }
    4552           0 :         PY_CHECK_TYPE(nbt_name_Type, py_name, return false;);
    4553           0 :         if (talloc_reference(r, pytalloc_get_mem_ctx(py_name)) == NULL) {
    4554           0 :                 PyErr_NoMemory();
    4555           0 :                 return false;
    4556             :         }
    4557           0 :         r->in.name = *(struct nbt_name *)pytalloc_get_ptr(py_name);
    4558           0 :         if (py_num_addrs == NULL) {
    4559           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.num_addrs");
    4560           0 :                 return false;
    4561             :         }
    4562             :         {
    4563           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.num_addrs));
    4564           0 :                 if (PyLong_Check(py_num_addrs)) {
    4565             :                         unsigned long long test_var;
    4566           0 :                         test_var = PyLong_AsUnsignedLongLong(py_num_addrs);
    4567           0 :                         if (PyErr_Occurred() != NULL) {
    4568           0 :                                 return false;
    4569             :                         }
    4570           0 :                         if (test_var > uint_max) {
    4571           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4572             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4573           0 :                                 return false;
    4574             :                         }
    4575           0 :                         r->in.num_addrs = test_var;
    4576             :                 } else {
    4577           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4578             :                           PyLong_Type.tp_name);
    4579           0 :                         return false;
    4580             :                 }
    4581             :         }
    4582           0 :         if (py_addrs == NULL) {
    4583           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.addrs");
    4584           0 :                 return false;
    4585             :         }
    4586           0 :         PY_CHECK_TYPE(&PyList_Type, py_addrs, return false;);
    4587             :         {
    4588             :                 int addrs_cntr_0;
    4589           0 :                 r->in.addrs = talloc_array_ptrtype(r, r->in.addrs, PyList_GET_SIZE(py_addrs));
    4590           0 :                 if (!r->in.addrs) { return false; }
    4591           0 :                 talloc_set_name_const(r->in.addrs, "ARRAY: r->in.addrs");
    4592           0 :                 for (addrs_cntr_0 = 0; addrs_cntr_0 < PyList_GET_SIZE(py_addrs); addrs_cntr_0++) {
    4593           0 :                         if (PyList_GET_ITEM(py_addrs, addrs_cntr_0) == NULL) {
    4594           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (r->in.addrs)[addrs_cntr_0]");
    4595           0 :                                 return false;
    4596             :                         }
    4597           0 :                         PY_CHECK_TYPE(&nbtd_proxy_wins_addr_Type, PyList_GET_ITEM(py_addrs, addrs_cntr_0), return false;);
    4598           0 :                         if (talloc_reference(r->in.addrs, pytalloc_get_mem_ctx(PyList_GET_ITEM(py_addrs, addrs_cntr_0))) == NULL) {
    4599           0 :                                 PyErr_NoMemory();
    4600           0 :                                 return false;
    4601             :                         }
    4602           0 :                         (r->in.addrs)[addrs_cntr_0] = *(struct nbtd_proxy_wins_addr *)pytalloc_get_ptr(PyList_GET_ITEM(py_addrs, addrs_cntr_0));
    4603             :                 }
    4604             :         }
    4605           0 :         return true;
    4606             : }
    4607             : 
    4608           0 : static PyObject *unpack_py_nbtd_proxy_wins_challenge_args_out(struct nbtd_proxy_wins_challenge *r)
    4609             : {
    4610             :         PyObject *result;
    4611             :         PyObject *py_num_addrs;
    4612             :         PyObject *py_addrs;
    4613           0 :         result = PyTuple_New(2);
    4614           0 :         py_num_addrs = PyLong_FromUnsignedLongLong((uint32_t)(r->out.num_addrs));
    4615           0 :         PyTuple_SetItem(result, 0, py_num_addrs);
    4616           0 :         py_addrs = PyList_New(r->out.num_addrs);
    4617           0 :         if (py_addrs == NULL) {
    4618           0 :                 return NULL;
    4619             :         }
    4620             :         {
    4621             :                 int addrs_cntr_0;
    4622           0 :                 for (addrs_cntr_0 = 0; addrs_cntr_0 < (r->out.num_addrs); addrs_cntr_0++) {
    4623             :                         PyObject *py_addrs_0;
    4624           0 :                         py_addrs_0 = pytalloc_reference_ex(&nbtd_proxy_wins_addr_Type, r->out.addrs, &(r->out.addrs)[addrs_cntr_0]);
    4625           0 :                         PyList_SetItem(py_addrs, addrs_cntr_0, py_addrs_0);
    4626             :                 }
    4627             :         }
    4628           0 :         PyTuple_SetItem(result, 1, py_addrs);
    4629           0 :         return result;
    4630             : }
    4631             : 
    4632             : 
    4633           0 : static PyObject *py_nbtd_proxy_wins_release_demand_in_get_name(PyObject *obj, void *closure)
    4634             : {
    4635           0 :         struct nbtd_proxy_wins_release_demand *object = pytalloc_get_ptr(obj);
    4636             :         PyObject *py_name;
    4637           0 :         py_name = pytalloc_reference_ex(nbt_name_Type, pytalloc_get_mem_ctx(obj), &object->in.name);
    4638           0 :         return py_name;
    4639             : }
    4640             : 
    4641           0 : static int py_nbtd_proxy_wins_release_demand_in_set_name(PyObject *py_obj, PyObject *value, void *closure)
    4642             : {
    4643           0 :         struct nbtd_proxy_wins_release_demand *object = pytalloc_get_ptr(py_obj);
    4644           0 :         if (value == NULL) {
    4645           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.name");
    4646           0 :                 return -1;
    4647             :         }
    4648           0 :         PY_CHECK_TYPE(nbt_name_Type, value, return -1;);
    4649           0 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    4650           0 :                 PyErr_NoMemory();
    4651           0 :                 return -1;
    4652             :         }
    4653           0 :         object->in.name = *(struct nbt_name *)pytalloc_get_ptr(value);
    4654           0 :         return 0;
    4655             : }
    4656             : 
    4657           0 : static PyObject *py_nbtd_proxy_wins_release_demand_in_get_num_addrs(PyObject *obj, void *closure)
    4658             : {
    4659           0 :         struct nbtd_proxy_wins_release_demand *object = pytalloc_get_ptr(obj);
    4660             :         PyObject *py_num_addrs;
    4661           0 :         py_num_addrs = PyLong_FromUnsignedLongLong((uint32_t)(object->in.num_addrs));
    4662           0 :         return py_num_addrs;
    4663             : }
    4664             : 
    4665           0 : static int py_nbtd_proxy_wins_release_demand_in_set_num_addrs(PyObject *py_obj, PyObject *value, void *closure)
    4666             : {
    4667           0 :         struct nbtd_proxy_wins_release_demand *object = pytalloc_get_ptr(py_obj);
    4668           0 :         if (value == NULL) {
    4669           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.num_addrs");
    4670           0 :                 return -1;
    4671             :         }
    4672             :         {
    4673           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.num_addrs));
    4674           0 :                 if (PyLong_Check(value)) {
    4675             :                         unsigned long long test_var;
    4676           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    4677           0 :                         if (PyErr_Occurred() != NULL) {
    4678           0 :                                 return -1;
    4679             :                         }
    4680           0 :                         if (test_var > uint_max) {
    4681           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4682             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4683           0 :                                 return -1;
    4684             :                         }
    4685           0 :                         object->in.num_addrs = test_var;
    4686             :                 } else {
    4687           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4688             :                           PyLong_Type.tp_name);
    4689           0 :                         return -1;
    4690             :                 }
    4691             :         }
    4692           0 :         return 0;
    4693             : }
    4694             : 
    4695           0 : static PyObject *py_nbtd_proxy_wins_release_demand_in_get_addrs(PyObject *obj, void *closure)
    4696             : {
    4697           0 :         struct nbtd_proxy_wins_release_demand *object = pytalloc_get_ptr(obj);
    4698             :         PyObject *py_addrs;
    4699           0 :         py_addrs = PyList_New(object->in.num_addrs);
    4700           0 :         if (py_addrs == NULL) {
    4701           0 :                 return NULL;
    4702             :         }
    4703             :         {
    4704             :                 int addrs_cntr_0;
    4705           0 :                 for (addrs_cntr_0 = 0; addrs_cntr_0 < (object->in.num_addrs); addrs_cntr_0++) {
    4706             :                         PyObject *py_addrs_0;
    4707           0 :                         py_addrs_0 = pytalloc_reference_ex(&nbtd_proxy_wins_addr_Type, object->in.addrs, &(object->in.addrs)[addrs_cntr_0]);
    4708           0 :                         PyList_SetItem(py_addrs, addrs_cntr_0, py_addrs_0);
    4709             :                 }
    4710             :         }
    4711           0 :         return py_addrs;
    4712             : }
    4713             : 
    4714           0 : static int py_nbtd_proxy_wins_release_demand_in_set_addrs(PyObject *py_obj, PyObject *value, void *closure)
    4715             : {
    4716           0 :         struct nbtd_proxy_wins_release_demand *object = pytalloc_get_ptr(py_obj);
    4717           0 :         if (value == NULL) {
    4718           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.addrs");
    4719           0 :                 return -1;
    4720             :         }
    4721           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
    4722             :         {
    4723             :                 int addrs_cntr_0;
    4724           0 :                 object->in.addrs = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.addrs, PyList_GET_SIZE(value));
    4725           0 :                 if (!object->in.addrs) { return -1; }
    4726           0 :                 talloc_set_name_const(object->in.addrs, "ARRAY: object->in.addrs");
    4727           0 :                 for (addrs_cntr_0 = 0; addrs_cntr_0 < PyList_GET_SIZE(value); addrs_cntr_0++) {
    4728           0 :                         if (PyList_GET_ITEM(value, addrs_cntr_0) == NULL) {
    4729           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->in.addrs)[addrs_cntr_0]");
    4730           0 :                                 return -1;
    4731             :                         }
    4732           0 :                         PY_CHECK_TYPE(&nbtd_proxy_wins_addr_Type, PyList_GET_ITEM(value, addrs_cntr_0), return -1;);
    4733           0 :                         if (talloc_reference(object->in.addrs, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, addrs_cntr_0))) == NULL) {
    4734           0 :                                 PyErr_NoMemory();
    4735           0 :                                 return -1;
    4736             :                         }
    4737           0 :                         (object->in.addrs)[addrs_cntr_0] = *(struct nbtd_proxy_wins_addr *)pytalloc_get_ptr(PyList_GET_ITEM(value, addrs_cntr_0));
    4738             :                 }
    4739             :         }
    4740           0 :         return 0;
    4741             : }
    4742             : 
    4743             : static PyGetSetDef py_nbtd_proxy_wins_release_demand_getsetters[] = {
    4744             :         {
    4745             :                 .name = discard_const_p(char, "in_name"),
    4746             :                 .get = py_nbtd_proxy_wins_release_demand_in_get_name,
    4747             :                 .set = py_nbtd_proxy_wins_release_demand_in_set_name,
    4748             :                 .doc = discard_const_p(char, "PIDL-generated element of base type nbt_name")
    4749             :         },
    4750             :         {
    4751             :                 .name = discard_const_p(char, "in_num_addrs"),
    4752             :                 .get = py_nbtd_proxy_wins_release_demand_in_get_num_addrs,
    4753             :                 .set = py_nbtd_proxy_wins_release_demand_in_set_num_addrs,
    4754             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    4755             :         },
    4756             :         {
    4757             :                 .name = discard_const_p(char, "in_addrs"),
    4758             :                 .get = py_nbtd_proxy_wins_release_demand_in_get_addrs,
    4759             :                 .set = py_nbtd_proxy_wins_release_demand_in_set_addrs,
    4760             :                 .doc = discard_const_p(char, "PIDL-generated element of base type nbtd_proxy_wins_addr")
    4761             :         },
    4762             :         { .name = NULL }
    4763             : };
    4764             : 
    4765           0 : static PyObject *py_nbtd_proxy_wins_release_demand_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    4766             : {
    4767           0 :         PyObject *self = pytalloc_new(struct nbtd_proxy_wins_release_demand, type);
    4768           0 :         return self;
    4769             : }
    4770             : 
    4771           0 : static PyObject *py_nbtd_proxy_wins_release_demand_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
    4772             : {
    4773             : 
    4774             : 
    4775           0 :         return PyLong_FromLong(4);
    4776             : }
    4777             : 
    4778           0 : static PyObject *py_nbtd_proxy_wins_release_demand_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
    4779             : {
    4780           0 :         const struct ndr_interface_call *call = NULL;
    4781           0 :         struct nbtd_proxy_wins_release_demand *object = pytalloc_get_ptr(py_obj);
    4782           0 :         PyObject *ret = NULL;
    4783           0 :         struct ndr_push *push = NULL;
    4784             :         DATA_BLOB blob;
    4785             :         enum ndr_err_code err;
    4786             : 
    4787           0 :         if (ndr_table_irpc.num_calls < 5) {
    4788           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_nbtd_proxy_wins_release_demand_ndr_pack");
    4789           0 :                 return NULL;
    4790             :         }
    4791           0 :         call = &ndr_table_irpc.calls[4];
    4792             : 
    4793           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
    4794           0 :         if (push == NULL) {
    4795           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    4796           0 :                 return NULL;
    4797             :         }
    4798             : 
    4799           0 :         push->flags |= ndr_push_flags;
    4800             : 
    4801           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
    4802           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    4803           0 :                 TALLOC_FREE(push);
    4804           0 :                 PyErr_SetNdrError(err);
    4805           0 :                 return NULL;
    4806             :         }
    4807           0 :         blob = ndr_push_blob(push);
    4808           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
    4809           0 :         TALLOC_FREE(push);
    4810           0 :         return ret;
    4811             : }
    4812             : 
    4813           0 : static PyObject *py_nbtd_proxy_wins_release_demand_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    4814             : {
    4815           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    4816           0 :         PyObject *bigendian_obj = NULL;
    4817           0 :         PyObject *ndr64_obj = NULL;
    4818           0 :         libndr_flags ndr_push_flags = 0;
    4819             : 
    4820           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
    4821             :                 discard_const_p(char *, kwnames),
    4822             :                 &bigendian_obj,
    4823             :                 &ndr64_obj)) {
    4824           0 :                 return NULL;
    4825             :         }
    4826             : 
    4827           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    4828           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    4829             :         }
    4830           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    4831           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    4832             :         }
    4833             : 
    4834           0 :         return py_nbtd_proxy_wins_release_demand_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
    4835             : }
    4836             : 
    4837           0 : static PyObject *py_nbtd_proxy_wins_release_demand_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    4838             : {
    4839           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    4840           0 :         PyObject *bigendian_obj = NULL;
    4841           0 :         PyObject *ndr64_obj = NULL;
    4842           0 :         libndr_flags ndr_push_flags = 0;
    4843             : 
    4844           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
    4845             :                 discard_const_p(char *, kwnames),
    4846             :                 &bigendian_obj,
    4847             :                 &ndr64_obj)) {
    4848           0 :                 return NULL;
    4849             :         }
    4850             : 
    4851           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    4852           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    4853             :         }
    4854           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    4855           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    4856             :         }
    4857             : 
    4858           0 :         return py_nbtd_proxy_wins_release_demand_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
    4859             : }
    4860             : 
    4861           0 : static PyObject *py_nbtd_proxy_wins_release_demand_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
    4862             : {
    4863           0 :         const struct ndr_interface_call *call = NULL;
    4864           0 :         struct nbtd_proxy_wins_release_demand *object = pytalloc_get_ptr(py_obj);
    4865           0 :         struct ndr_pull *pull = NULL;
    4866             :         enum ndr_err_code err;
    4867             : 
    4868           0 :         if (ndr_table_irpc.num_calls < 5) {
    4869           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_nbtd_proxy_wins_release_demand_ndr_unpack");
    4870           0 :                 return NULL;
    4871             :         }
    4872           0 :         call = &ndr_table_irpc.calls[4];
    4873             : 
    4874           0 :         pull = ndr_pull_init_blob(blob, object);
    4875           0 :         if (pull == NULL) {
    4876           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    4877           0 :                 return NULL;
    4878             :         }
    4879             : 
    4880           0 :         pull->flags |= ndr_pull_flags;
    4881             : 
    4882           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
    4883           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    4884           0 :                 TALLOC_FREE(pull);
    4885           0 :                 PyErr_SetNdrError(err);
    4886           0 :                 return NULL;
    4887             :         }
    4888           0 :         if (!allow_remaining) {
    4889             :                 uint32_t highest_ofs;
    4890             : 
    4891           0 :                 if (pull->offset > pull->relative_highest_offset) {
    4892           0 :                         highest_ofs = pull->offset;
    4893             :                 } else {
    4894           0 :                         highest_ofs = pull->relative_highest_offset;
    4895             :                 }
    4896           0 :                 if (highest_ofs < pull->data_size) {
    4897           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
    4898             :                                 "not all bytes consumed ofs[%u] size[%u]",
    4899             :                                 highest_ofs, pull->data_size);
    4900           0 :                         TALLOC_FREE(pull);
    4901           0 :                         PyErr_SetNdrError(err);
    4902           0 :                         return NULL;
    4903             :                 }
    4904             :         }
    4905             : 
    4906           0 :         TALLOC_FREE(pull);
    4907           0 :         Py_RETURN_NONE;
    4908             : }
    4909             : 
    4910           0 : static PyObject *py_nbtd_proxy_wins_release_demand_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    4911             : {
    4912             :         DATA_BLOB blob;
    4913           0 :         Py_ssize_t blob_length = 0;
    4914           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    4915           0 :         PyObject *bigendian_obj = NULL;
    4916           0 :         PyObject *ndr64_obj = NULL;
    4917           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    4918           0 :         PyObject *allow_remaining_obj = NULL;
    4919           0 :         bool allow_remaining = false;
    4920             : 
    4921           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
    4922             :                 discard_const_p(char *, kwnames),
    4923             :                 &blob.data, &blob_length,
    4924             :                 &bigendian_obj,
    4925             :                 &ndr64_obj,
    4926             :                 &allow_remaining_obj)) {
    4927           0 :                 return NULL;
    4928             :         }
    4929           0 :         blob.length = blob_length;
    4930             : 
    4931           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    4932           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    4933             :         }
    4934           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    4935           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    4936             :         }
    4937             : 
    4938           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    4939           0 :                 allow_remaining = true;
    4940             :         }
    4941             : 
    4942           0 :         return py_nbtd_proxy_wins_release_demand_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
    4943             : }
    4944             : 
    4945           0 : static PyObject *py_nbtd_proxy_wins_release_demand_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    4946             : {
    4947             :         DATA_BLOB blob;
    4948           0 :         Py_ssize_t blob_length = 0;
    4949           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    4950           0 :         PyObject *bigendian_obj = NULL;
    4951           0 :         PyObject *ndr64_obj = NULL;
    4952           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    4953           0 :         PyObject *allow_remaining_obj = NULL;
    4954           0 :         bool allow_remaining = false;
    4955             : 
    4956           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
    4957             :                 discard_const_p(char *, kwnames),
    4958             :                 &blob.data, &blob_length,
    4959             :                 &bigendian_obj,
    4960             :                 &ndr64_obj,
    4961             :                 &allow_remaining_obj)) {
    4962           0 :                 return NULL;
    4963             :         }
    4964           0 :         blob.length = blob_length;
    4965             : 
    4966           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    4967           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    4968             :         }
    4969           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    4970           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    4971             :         }
    4972             : 
    4973           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    4974           0 :                 allow_remaining = true;
    4975             :         }
    4976             : 
    4977           0 :         return py_nbtd_proxy_wins_release_demand_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
    4978             : }
    4979             : 
    4980           0 : static PyObject *py_nbtd_proxy_wins_release_demand_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
    4981             : {
    4982           0 :         const struct ndr_interface_call *call = NULL;
    4983           0 :         struct nbtd_proxy_wins_release_demand *object = pytalloc_get_ptr(py_obj);
    4984             :         PyObject *ret;
    4985             :         char *retstr;
    4986             : 
    4987           0 :         if (ndr_table_irpc.num_calls < 5) {
    4988           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_nbtd_proxy_wins_release_demand_ndr_print");
    4989           0 :                 return NULL;
    4990             :         }
    4991           0 :         call = &ndr_table_irpc.calls[4];
    4992             : 
    4993           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
    4994           0 :         ret = PyUnicode_FromString(retstr);
    4995           0 :         TALLOC_FREE(retstr);
    4996             : 
    4997           0 :         return ret;
    4998             : }
    4999             : 
    5000           0 : static PyObject *py_nbtd_proxy_wins_release_demand_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    5001             : {
    5002           0 :         return py_nbtd_proxy_wins_release_demand_ndr_print(py_obj, "nbtd_proxy_wins_release_demand_in", NDR_IN);
    5003             : }
    5004             : 
    5005           0 : static PyObject *py_nbtd_proxy_wins_release_demand_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    5006             : {
    5007           0 :         return py_nbtd_proxy_wins_release_demand_ndr_print(py_obj, "nbtd_proxy_wins_release_demand_out", NDR_OUT);
    5008             : }
    5009             : 
    5010             : static PyMethodDef py_nbtd_proxy_wins_release_demand_methods[] = {
    5011             :         { "opnum", (PyCFunction)py_nbtd_proxy_wins_release_demand_ndr_opnum, METH_NOARGS|METH_CLASS,
    5012             :                 "irpc.nbtd_proxy_wins_release_demand.opnum() -> 4 (0x04) " },
    5013             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_nbtd_proxy_wins_release_demand_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
    5014             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
    5015             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_nbtd_proxy_wins_release_demand_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
    5016             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
    5017             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_nbtd_proxy_wins_release_demand_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
    5018             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
    5019             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_nbtd_proxy_wins_release_demand_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
    5020             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
    5021             :         { "__ndr_print_in__", (PyCFunction)py_nbtd_proxy_wins_release_demand_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
    5022             :         { "__ndr_print_out__", (PyCFunction)py_nbtd_proxy_wins_release_demand_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
    5023             :         { NULL, NULL, 0, NULL }
    5024             : };
    5025             : 
    5026             : 
    5027             : static PyTypeObject nbtd_proxy_wins_release_demand_Type = {
    5028             :         PyVarObject_HEAD_INIT(NULL, 0)
    5029             :         .tp_name = "irpc.nbtd_proxy_wins_release_demand",
    5030             :         .tp_getset = py_nbtd_proxy_wins_release_demand_getsetters,
    5031             :         .tp_methods = py_nbtd_proxy_wins_release_demand_methods,
    5032             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    5033             :         .tp_new = py_nbtd_proxy_wins_release_demand_new,
    5034             : };
    5035             : 
    5036           0 : static bool pack_py_nbtd_proxy_wins_release_demand_args_in(PyObject *args, PyObject *kwargs, struct nbtd_proxy_wins_release_demand *r)
    5037             : {
    5038             :         PyObject *py_name;
    5039             :         PyObject *py_num_addrs;
    5040             :         PyObject *py_addrs;
    5041           0 :         const char *kwnames[] = {
    5042             :                 "name", "num_addrs", "addrs", NULL
    5043             :         };
    5044             : 
    5045           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:nbtd_proxy_wins_release_demand", discard_const_p(char *, kwnames), &py_name, &py_num_addrs, &py_addrs)) {
    5046           0 :                 return false;
    5047             :         }
    5048             : 
    5049           0 :         if (py_name == NULL) {
    5050           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.name");
    5051           0 :                 return false;
    5052             :         }
    5053           0 :         PY_CHECK_TYPE(nbt_name_Type, py_name, return false;);
    5054           0 :         if (talloc_reference(r, pytalloc_get_mem_ctx(py_name)) == NULL) {
    5055           0 :                 PyErr_NoMemory();
    5056           0 :                 return false;
    5057             :         }
    5058           0 :         r->in.name = *(struct nbt_name *)pytalloc_get_ptr(py_name);
    5059           0 :         if (py_num_addrs == NULL) {
    5060           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.num_addrs");
    5061           0 :                 return false;
    5062             :         }
    5063             :         {
    5064           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.num_addrs));
    5065           0 :                 if (PyLong_Check(py_num_addrs)) {
    5066             :                         unsigned long long test_var;
    5067           0 :                         test_var = PyLong_AsUnsignedLongLong(py_num_addrs);
    5068           0 :                         if (PyErr_Occurred() != NULL) {
    5069           0 :                                 return false;
    5070             :                         }
    5071           0 :                         if (test_var > uint_max) {
    5072           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    5073             :                                   PyLong_Type.tp_name, uint_max, test_var);
    5074           0 :                                 return false;
    5075             :                         }
    5076           0 :                         r->in.num_addrs = test_var;
    5077             :                 } else {
    5078           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    5079             :                           PyLong_Type.tp_name);
    5080           0 :                         return false;
    5081             :                 }
    5082             :         }
    5083           0 :         if (py_addrs == NULL) {
    5084           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.addrs");
    5085           0 :                 return false;
    5086             :         }
    5087           0 :         PY_CHECK_TYPE(&PyList_Type, py_addrs, return false;);
    5088             :         {
    5089             :                 int addrs_cntr_0;
    5090           0 :                 r->in.addrs = talloc_array_ptrtype(r, r->in.addrs, PyList_GET_SIZE(py_addrs));
    5091           0 :                 if (!r->in.addrs) { return false; }
    5092           0 :                 talloc_set_name_const(r->in.addrs, "ARRAY: r->in.addrs");
    5093           0 :                 for (addrs_cntr_0 = 0; addrs_cntr_0 < PyList_GET_SIZE(py_addrs); addrs_cntr_0++) {
    5094           0 :                         if (PyList_GET_ITEM(py_addrs, addrs_cntr_0) == NULL) {
    5095           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (r->in.addrs)[addrs_cntr_0]");
    5096           0 :                                 return false;
    5097             :                         }
    5098           0 :                         PY_CHECK_TYPE(&nbtd_proxy_wins_addr_Type, PyList_GET_ITEM(py_addrs, addrs_cntr_0), return false;);
    5099           0 :                         if (talloc_reference(r->in.addrs, pytalloc_get_mem_ctx(PyList_GET_ITEM(py_addrs, addrs_cntr_0))) == NULL) {
    5100           0 :                                 PyErr_NoMemory();
    5101           0 :                                 return false;
    5102             :                         }
    5103           0 :                         (r->in.addrs)[addrs_cntr_0] = *(struct nbtd_proxy_wins_addr *)pytalloc_get_ptr(PyList_GET_ITEM(py_addrs, addrs_cntr_0));
    5104             :                 }
    5105             :         }
    5106           0 :         return true;
    5107             : }
    5108             : 
    5109           0 : static PyObject *unpack_py_nbtd_proxy_wins_release_demand_args_out(struct nbtd_proxy_wins_release_demand *r)
    5110             : {
    5111             :         PyObject *result;
    5112           0 :         result = Py_None;
    5113           0 :         Py_INCREF(result);
    5114           0 :         return result;
    5115             : }
    5116             : 
    5117             : 
    5118           0 : static PyObject *py_kdc_check_generic_kerberos_in_get_generic_request(PyObject *obj, void *closure)
    5119             : {
    5120           0 :         struct kdc_check_generic_kerberos *object = pytalloc_get_ptr(obj);
    5121             :         PyObject *py_generic_request;
    5122           0 :         py_generic_request = PyBytes_FromStringAndSize((char *)(object->in.generic_request).data, (object->in.generic_request).length);
    5123           0 :         return py_generic_request;
    5124             : }
    5125             : 
    5126           0 : static int py_kdc_check_generic_kerberos_in_set_generic_request(PyObject *py_obj, PyObject *value, void *closure)
    5127             : {
    5128           0 :         struct kdc_check_generic_kerberos *object = pytalloc_get_ptr(py_obj);
    5129           0 :         if (value == NULL) {
    5130           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.generic_request");
    5131           0 :                 return -1;
    5132             :         }
    5133           0 :         object->in.generic_request = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyBytes_AS_STRING(value), PyBytes_GET_SIZE(value));
    5134           0 :         return 0;
    5135             : }
    5136             : 
    5137           0 : static PyObject *py_kdc_check_generic_kerberos_out_get_generic_reply(PyObject *obj, void *closure)
    5138             : {
    5139           0 :         struct kdc_check_generic_kerberos *object = pytalloc_get_ptr(obj);
    5140             :         PyObject *py_generic_reply;
    5141           0 :         py_generic_reply = PyBytes_FromStringAndSize((char *)(object->out.generic_reply).data, (object->out.generic_reply).length);
    5142           0 :         return py_generic_reply;
    5143             : }
    5144             : 
    5145           0 : static int py_kdc_check_generic_kerberos_out_set_generic_reply(PyObject *py_obj, PyObject *value, void *closure)
    5146             : {
    5147           0 :         struct kdc_check_generic_kerberos *object = pytalloc_get_ptr(py_obj);
    5148           0 :         if (value == NULL) {
    5149           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.generic_reply");
    5150           0 :                 return -1;
    5151             :         }
    5152           0 :         object->out.generic_reply = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyBytes_AS_STRING(value), PyBytes_GET_SIZE(value));
    5153           0 :         return 0;
    5154             : }
    5155             : 
    5156             : static PyGetSetDef py_kdc_check_generic_kerberos_getsetters[] = {
    5157             :         {
    5158             :                 .name = discard_const_p(char, "in_generic_request"),
    5159             :                 .get = py_kdc_check_generic_kerberos_in_get_generic_request,
    5160             :                 .set = py_kdc_check_generic_kerberos_in_set_generic_request,
    5161             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DATA_BLOB")
    5162             :         },
    5163             :         {
    5164             :                 .name = discard_const_p(char, "out_generic_reply"),
    5165             :                 .get = py_kdc_check_generic_kerberos_out_get_generic_reply,
    5166             :                 .set = py_kdc_check_generic_kerberos_out_set_generic_reply,
    5167             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DATA_BLOB")
    5168             :         },
    5169             :         { .name = NULL }
    5170             : };
    5171             : 
    5172           0 : static PyObject *py_kdc_check_generic_kerberos_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    5173             : {
    5174           0 :         PyObject *self = pytalloc_new(struct kdc_check_generic_kerberos, type);
    5175           0 :         return self;
    5176             : }
    5177             : 
    5178           0 : static PyObject *py_kdc_check_generic_kerberos_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
    5179             : {
    5180             : 
    5181             : 
    5182           0 :         return PyLong_FromLong(5);
    5183             : }
    5184             : 
    5185           0 : static PyObject *py_kdc_check_generic_kerberos_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
    5186             : {
    5187           0 :         const struct ndr_interface_call *call = NULL;
    5188           0 :         struct kdc_check_generic_kerberos *object = pytalloc_get_ptr(py_obj);
    5189           0 :         PyObject *ret = NULL;
    5190           0 :         struct ndr_push *push = NULL;
    5191             :         DATA_BLOB blob;
    5192             :         enum ndr_err_code err;
    5193             : 
    5194           0 :         if (ndr_table_irpc.num_calls < 6) {
    5195           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_kdc_check_generic_kerberos_ndr_pack");
    5196           0 :                 return NULL;
    5197             :         }
    5198           0 :         call = &ndr_table_irpc.calls[5];
    5199             : 
    5200           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
    5201           0 :         if (push == NULL) {
    5202           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    5203           0 :                 return NULL;
    5204             :         }
    5205             : 
    5206           0 :         push->flags |= ndr_push_flags;
    5207             : 
    5208           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
    5209           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    5210           0 :                 TALLOC_FREE(push);
    5211           0 :                 PyErr_SetNdrError(err);
    5212           0 :                 return NULL;
    5213             :         }
    5214           0 :         blob = ndr_push_blob(push);
    5215           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
    5216           0 :         TALLOC_FREE(push);
    5217           0 :         return ret;
    5218             : }
    5219             : 
    5220           0 : static PyObject *py_kdc_check_generic_kerberos_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    5221             : {
    5222           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    5223           0 :         PyObject *bigendian_obj = NULL;
    5224           0 :         PyObject *ndr64_obj = NULL;
    5225           0 :         libndr_flags ndr_push_flags = 0;
    5226             : 
    5227           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
    5228             :                 discard_const_p(char *, kwnames),
    5229             :                 &bigendian_obj,
    5230             :                 &ndr64_obj)) {
    5231           0 :                 return NULL;
    5232             :         }
    5233             : 
    5234           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    5235           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    5236             :         }
    5237           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    5238           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    5239             :         }
    5240             : 
    5241           0 :         return py_kdc_check_generic_kerberos_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
    5242             : }
    5243             : 
    5244           0 : static PyObject *py_kdc_check_generic_kerberos_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    5245             : {
    5246           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    5247           0 :         PyObject *bigendian_obj = NULL;
    5248           0 :         PyObject *ndr64_obj = NULL;
    5249           0 :         libndr_flags ndr_push_flags = 0;
    5250             : 
    5251           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
    5252             :                 discard_const_p(char *, kwnames),
    5253             :                 &bigendian_obj,
    5254             :                 &ndr64_obj)) {
    5255           0 :                 return NULL;
    5256             :         }
    5257             : 
    5258           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    5259           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    5260             :         }
    5261           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    5262           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    5263             :         }
    5264             : 
    5265           0 :         return py_kdc_check_generic_kerberos_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
    5266             : }
    5267             : 
    5268           0 : static PyObject *py_kdc_check_generic_kerberos_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
    5269             : {
    5270           0 :         const struct ndr_interface_call *call = NULL;
    5271           0 :         struct kdc_check_generic_kerberos *object = pytalloc_get_ptr(py_obj);
    5272           0 :         struct ndr_pull *pull = NULL;
    5273             :         enum ndr_err_code err;
    5274             : 
    5275           0 :         if (ndr_table_irpc.num_calls < 6) {
    5276           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_kdc_check_generic_kerberos_ndr_unpack");
    5277           0 :                 return NULL;
    5278             :         }
    5279           0 :         call = &ndr_table_irpc.calls[5];
    5280             : 
    5281           0 :         pull = ndr_pull_init_blob(blob, object);
    5282           0 :         if (pull == NULL) {
    5283           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    5284           0 :                 return NULL;
    5285             :         }
    5286             : 
    5287           0 :         pull->flags |= ndr_pull_flags;
    5288             : 
    5289           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
    5290           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    5291           0 :                 TALLOC_FREE(pull);
    5292           0 :                 PyErr_SetNdrError(err);
    5293           0 :                 return NULL;
    5294             :         }
    5295           0 :         if (!allow_remaining) {
    5296             :                 uint32_t highest_ofs;
    5297             : 
    5298           0 :                 if (pull->offset > pull->relative_highest_offset) {
    5299           0 :                         highest_ofs = pull->offset;
    5300             :                 } else {
    5301           0 :                         highest_ofs = pull->relative_highest_offset;
    5302             :                 }
    5303           0 :                 if (highest_ofs < pull->data_size) {
    5304           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
    5305             :                                 "not all bytes consumed ofs[%u] size[%u]",
    5306             :                                 highest_ofs, pull->data_size);
    5307           0 :                         TALLOC_FREE(pull);
    5308           0 :                         PyErr_SetNdrError(err);
    5309           0 :                         return NULL;
    5310             :                 }
    5311             :         }
    5312             : 
    5313           0 :         TALLOC_FREE(pull);
    5314           0 :         Py_RETURN_NONE;
    5315             : }
    5316             : 
    5317           0 : static PyObject *py_kdc_check_generic_kerberos_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    5318             : {
    5319             :         DATA_BLOB blob;
    5320           0 :         Py_ssize_t blob_length = 0;
    5321           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    5322           0 :         PyObject *bigendian_obj = NULL;
    5323           0 :         PyObject *ndr64_obj = NULL;
    5324           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    5325           0 :         PyObject *allow_remaining_obj = NULL;
    5326           0 :         bool allow_remaining = false;
    5327             : 
    5328           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
    5329             :                 discard_const_p(char *, kwnames),
    5330             :                 &blob.data, &blob_length,
    5331             :                 &bigendian_obj,
    5332             :                 &ndr64_obj,
    5333             :                 &allow_remaining_obj)) {
    5334           0 :                 return NULL;
    5335             :         }
    5336           0 :         blob.length = blob_length;
    5337             : 
    5338           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    5339           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    5340             :         }
    5341           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    5342           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    5343             :         }
    5344             : 
    5345           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    5346           0 :                 allow_remaining = true;
    5347             :         }
    5348             : 
    5349           0 :         return py_kdc_check_generic_kerberos_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
    5350             : }
    5351             : 
    5352           0 : static PyObject *py_kdc_check_generic_kerberos_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    5353             : {
    5354             :         DATA_BLOB blob;
    5355           0 :         Py_ssize_t blob_length = 0;
    5356           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    5357           0 :         PyObject *bigendian_obj = NULL;
    5358           0 :         PyObject *ndr64_obj = NULL;
    5359           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    5360           0 :         PyObject *allow_remaining_obj = NULL;
    5361           0 :         bool allow_remaining = false;
    5362             : 
    5363           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
    5364             :                 discard_const_p(char *, kwnames),
    5365             :                 &blob.data, &blob_length,
    5366             :                 &bigendian_obj,
    5367             :                 &ndr64_obj,
    5368             :                 &allow_remaining_obj)) {
    5369           0 :                 return NULL;
    5370             :         }
    5371           0 :         blob.length = blob_length;
    5372             : 
    5373           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    5374           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    5375             :         }
    5376           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    5377           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    5378             :         }
    5379             : 
    5380           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    5381           0 :                 allow_remaining = true;
    5382             :         }
    5383             : 
    5384           0 :         return py_kdc_check_generic_kerberos_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
    5385             : }
    5386             : 
    5387           0 : static PyObject *py_kdc_check_generic_kerberos_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
    5388             : {
    5389           0 :         const struct ndr_interface_call *call = NULL;
    5390           0 :         struct kdc_check_generic_kerberos *object = pytalloc_get_ptr(py_obj);
    5391             :         PyObject *ret;
    5392             :         char *retstr;
    5393             : 
    5394           0 :         if (ndr_table_irpc.num_calls < 6) {
    5395           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_kdc_check_generic_kerberos_ndr_print");
    5396           0 :                 return NULL;
    5397             :         }
    5398           0 :         call = &ndr_table_irpc.calls[5];
    5399             : 
    5400           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
    5401           0 :         ret = PyUnicode_FromString(retstr);
    5402           0 :         TALLOC_FREE(retstr);
    5403             : 
    5404           0 :         return ret;
    5405             : }
    5406             : 
    5407           0 : static PyObject *py_kdc_check_generic_kerberos_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    5408             : {
    5409           0 :         return py_kdc_check_generic_kerberos_ndr_print(py_obj, "kdc_check_generic_kerberos_in", NDR_IN);
    5410             : }
    5411             : 
    5412           0 : static PyObject *py_kdc_check_generic_kerberos_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    5413             : {
    5414           0 :         return py_kdc_check_generic_kerberos_ndr_print(py_obj, "kdc_check_generic_kerberos_out", NDR_OUT);
    5415             : }
    5416             : 
    5417             : static PyMethodDef py_kdc_check_generic_kerberos_methods[] = {
    5418             :         { "opnum", (PyCFunction)py_kdc_check_generic_kerberos_ndr_opnum, METH_NOARGS|METH_CLASS,
    5419             :                 "irpc.kdc_check_generic_kerberos.opnum() -> 5 (0x05) " },
    5420             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_kdc_check_generic_kerberos_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
    5421             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
    5422             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_kdc_check_generic_kerberos_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
    5423             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
    5424             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_kdc_check_generic_kerberos_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
    5425             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
    5426             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_kdc_check_generic_kerberos_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
    5427             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
    5428             :         { "__ndr_print_in__", (PyCFunction)py_kdc_check_generic_kerberos_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
    5429             :         { "__ndr_print_out__", (PyCFunction)py_kdc_check_generic_kerberos_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
    5430             :         { NULL, NULL, 0, NULL }
    5431             : };
    5432             : 
    5433             : 
    5434             : static PyTypeObject kdc_check_generic_kerberos_Type = {
    5435             :         PyVarObject_HEAD_INIT(NULL, 0)
    5436             :         .tp_name = "irpc.kdc_check_generic_kerberos",
    5437             :         .tp_getset = py_kdc_check_generic_kerberos_getsetters,
    5438             :         .tp_methods = py_kdc_check_generic_kerberos_methods,
    5439             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    5440             :         .tp_new = py_kdc_check_generic_kerberos_new,
    5441             : };
    5442             : 
    5443           0 : static bool pack_py_kdc_check_generic_kerberos_args_in(PyObject *args, PyObject *kwargs, struct kdc_check_generic_kerberos *r)
    5444             : {
    5445             :         PyObject *py_generic_request;
    5446           0 :         const char *kwnames[] = {
    5447             :                 "generic_request", NULL
    5448             :         };
    5449             : 
    5450           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:kdc_check_generic_kerberos", discard_const_p(char *, kwnames), &py_generic_request)) {
    5451           0 :                 return false;
    5452             :         }
    5453             : 
    5454           0 :         if (py_generic_request == NULL) {
    5455           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.generic_request");
    5456           0 :                 return false;
    5457             :         }
    5458           0 :         r->in.generic_request = data_blob_talloc(r, PyBytes_AS_STRING(py_generic_request), PyBytes_GET_SIZE(py_generic_request));
    5459           0 :         return true;
    5460             : }
    5461             : 
    5462           0 : static PyObject *unpack_py_kdc_check_generic_kerberos_args_out(struct kdc_check_generic_kerberos *r)
    5463             : {
    5464             :         PyObject *result;
    5465             :         PyObject *py_generic_reply;
    5466           0 :         py_generic_reply = PyBytes_FromStringAndSize((char *)(r->out.generic_reply).data, (r->out.generic_reply).length);
    5467           0 :         result = py_generic_reply;
    5468           0 :         return result;
    5469             : }
    5470             : 
    5471             : 
    5472           0 : static PyObject *py_smbsrv_information_in_get_level(PyObject *obj, void *closure)
    5473             : {
    5474           0 :         struct smbsrv_information *object = pytalloc_get_ptr(obj);
    5475             :         PyObject *py_level;
    5476           0 :         py_level = PyLong_FromUnsignedLongLong((uint32_t)(object->in.level));
    5477           0 :         return py_level;
    5478             : }
    5479             : 
    5480           0 : static int py_smbsrv_information_in_set_level(PyObject *py_obj, PyObject *value, void *closure)
    5481             : {
    5482           0 :         struct smbsrv_information *object = pytalloc_get_ptr(py_obj);
    5483           0 :         if (value == NULL) {
    5484           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.level");
    5485           0 :                 return -1;
    5486             :         }
    5487             :         {
    5488           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.level));
    5489           0 :                 if (PyLong_Check(value)) {
    5490             :                         unsigned long long test_var;
    5491           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    5492           0 :                         if (PyErr_Occurred() != NULL) {
    5493           0 :                                 return -1;
    5494             :                         }
    5495           0 :                         if (test_var > uint_max) {
    5496           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    5497             :                                   PyLong_Type.tp_name, uint_max, test_var);
    5498           0 :                                 return -1;
    5499             :                         }
    5500           0 :                         object->in.level = test_var;
    5501             :                 } else {
    5502           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    5503             :                           PyLong_Type.tp_name);
    5504           0 :                         return -1;
    5505             :                 }
    5506             :         }
    5507           0 :         return 0;
    5508             : }
    5509             : 
    5510           0 : static PyObject *py_smbsrv_information_out_get_info(PyObject *obj, void *closure)
    5511             : {
    5512           0 :         struct smbsrv_information *object = pytalloc_get_ptr(obj);
    5513             :         PyObject *py_info;
    5514           0 :         py_info = pyrpc_import_union(&smbsrv_info_Type, pytalloc_get_mem_ctx(obj), object->in.level, &object->out.info, "union smbsrv_info");
    5515           0 :         if (py_info == NULL) {
    5516           0 :                 return NULL;
    5517             :         }
    5518           0 :         return py_info;
    5519             : }
    5520             : 
    5521           0 : static int py_smbsrv_information_out_set_info(PyObject *py_obj, PyObject *value, void *closure)
    5522             : {
    5523           0 :         struct smbsrv_information *object = pytalloc_get_ptr(py_obj);
    5524           0 :         if (value == NULL) {
    5525           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.info");
    5526           0 :                 return -1;
    5527             :         }
    5528             :         {
    5529             :                 union smbsrv_info *info_switch_0;
    5530           0 :                 info_switch_0 = (union smbsrv_info *)pyrpc_export_union(&smbsrv_info_Type, pytalloc_get_mem_ctx(py_obj), object->in.level, value, "union smbsrv_info");
    5531           0 :                 if (info_switch_0 == NULL) {
    5532           0 :                         return -1;
    5533             :                 }
    5534           0 :                 object->out.info = *info_switch_0;
    5535             :         }
    5536           0 :         return 0;
    5537             : }
    5538             : 
    5539             : static PyGetSetDef py_smbsrv_information_getsetters[] = {
    5540             :         {
    5541             :                 .name = discard_const_p(char, "in_level"),
    5542             :                 .get = py_smbsrv_information_in_get_level,
    5543             :                 .set = py_smbsrv_information_in_set_level,
    5544             :                 .doc = discard_const_p(char, "PIDL-generated element of base type smbsrv_info_level")
    5545             :         },
    5546             :         {
    5547             :                 .name = discard_const_p(char, "out_info"),
    5548             :                 .get = py_smbsrv_information_out_get_info,
    5549             :                 .set = py_smbsrv_information_out_set_info,
    5550             :                 .doc = discard_const_p(char, "PIDL-generated element of base type smbsrv_info")
    5551             :         },
    5552             :         { .name = NULL }
    5553             : };
    5554             : 
    5555           0 : static PyObject *py_smbsrv_information_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    5556             : {
    5557           0 :         PyObject *self = pytalloc_new(struct smbsrv_information, type);
    5558           0 :         return self;
    5559             : }
    5560             : 
    5561           0 : static PyObject *py_smbsrv_information_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
    5562             : {
    5563             : 
    5564             : 
    5565           0 :         return PyLong_FromLong(6);
    5566             : }
    5567             : 
    5568           0 : static PyObject *py_smbsrv_information_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
    5569             : {
    5570           0 :         const struct ndr_interface_call *call = NULL;
    5571           0 :         struct smbsrv_information *object = pytalloc_get_ptr(py_obj);
    5572           0 :         PyObject *ret = NULL;
    5573           0 :         struct ndr_push *push = NULL;
    5574             :         DATA_BLOB blob;
    5575             :         enum ndr_err_code err;
    5576             : 
    5577           0 :         if (ndr_table_irpc.num_calls < 7) {
    5578           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_smbsrv_information_ndr_pack");
    5579           0 :                 return NULL;
    5580             :         }
    5581           0 :         call = &ndr_table_irpc.calls[6];
    5582             : 
    5583           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
    5584           0 :         if (push == NULL) {
    5585           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    5586           0 :                 return NULL;
    5587             :         }
    5588             : 
    5589           0 :         push->flags |= ndr_push_flags;
    5590             : 
    5591           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
    5592           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    5593           0 :                 TALLOC_FREE(push);
    5594           0 :                 PyErr_SetNdrError(err);
    5595           0 :                 return NULL;
    5596             :         }
    5597           0 :         blob = ndr_push_blob(push);
    5598           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
    5599           0 :         TALLOC_FREE(push);
    5600           0 :         return ret;
    5601             : }
    5602             : 
    5603           0 : static PyObject *py_smbsrv_information_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    5604             : {
    5605           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    5606           0 :         PyObject *bigendian_obj = NULL;
    5607           0 :         PyObject *ndr64_obj = NULL;
    5608           0 :         libndr_flags ndr_push_flags = 0;
    5609             : 
    5610           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
    5611             :                 discard_const_p(char *, kwnames),
    5612             :                 &bigendian_obj,
    5613             :                 &ndr64_obj)) {
    5614           0 :                 return NULL;
    5615             :         }
    5616             : 
    5617           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    5618           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    5619             :         }
    5620           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    5621           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    5622             :         }
    5623             : 
    5624           0 :         return py_smbsrv_information_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
    5625             : }
    5626             : 
    5627           0 : static PyObject *py_smbsrv_information_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    5628             : {
    5629           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    5630           0 :         PyObject *bigendian_obj = NULL;
    5631           0 :         PyObject *ndr64_obj = NULL;
    5632           0 :         libndr_flags ndr_push_flags = 0;
    5633             : 
    5634           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
    5635             :                 discard_const_p(char *, kwnames),
    5636             :                 &bigendian_obj,
    5637             :                 &ndr64_obj)) {
    5638           0 :                 return NULL;
    5639             :         }
    5640             : 
    5641           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    5642           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    5643             :         }
    5644           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    5645           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    5646             :         }
    5647             : 
    5648           0 :         return py_smbsrv_information_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
    5649             : }
    5650             : 
    5651           0 : static PyObject *py_smbsrv_information_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
    5652             : {
    5653           0 :         const struct ndr_interface_call *call = NULL;
    5654           0 :         struct smbsrv_information *object = pytalloc_get_ptr(py_obj);
    5655           0 :         struct ndr_pull *pull = NULL;
    5656             :         enum ndr_err_code err;
    5657             : 
    5658           0 :         if (ndr_table_irpc.num_calls < 7) {
    5659           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_smbsrv_information_ndr_unpack");
    5660           0 :                 return NULL;
    5661             :         }
    5662           0 :         call = &ndr_table_irpc.calls[6];
    5663             : 
    5664           0 :         pull = ndr_pull_init_blob(blob, object);
    5665           0 :         if (pull == NULL) {
    5666           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    5667           0 :                 return NULL;
    5668             :         }
    5669             : 
    5670           0 :         pull->flags |= ndr_pull_flags;
    5671             : 
    5672           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
    5673           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    5674           0 :                 TALLOC_FREE(pull);
    5675           0 :                 PyErr_SetNdrError(err);
    5676           0 :                 return NULL;
    5677             :         }
    5678           0 :         if (!allow_remaining) {
    5679             :                 uint32_t highest_ofs;
    5680             : 
    5681           0 :                 if (pull->offset > pull->relative_highest_offset) {
    5682           0 :                         highest_ofs = pull->offset;
    5683             :                 } else {
    5684           0 :                         highest_ofs = pull->relative_highest_offset;
    5685             :                 }
    5686           0 :                 if (highest_ofs < pull->data_size) {
    5687           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
    5688             :                                 "not all bytes consumed ofs[%u] size[%u]",
    5689             :                                 highest_ofs, pull->data_size);
    5690           0 :                         TALLOC_FREE(pull);
    5691           0 :                         PyErr_SetNdrError(err);
    5692           0 :                         return NULL;
    5693             :                 }
    5694             :         }
    5695             : 
    5696           0 :         TALLOC_FREE(pull);
    5697           0 :         Py_RETURN_NONE;
    5698             : }
    5699             : 
    5700           0 : static PyObject *py_smbsrv_information_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    5701             : {
    5702             :         DATA_BLOB blob;
    5703           0 :         Py_ssize_t blob_length = 0;
    5704           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    5705           0 :         PyObject *bigendian_obj = NULL;
    5706           0 :         PyObject *ndr64_obj = NULL;
    5707           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    5708           0 :         PyObject *allow_remaining_obj = NULL;
    5709           0 :         bool allow_remaining = false;
    5710             : 
    5711           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
    5712             :                 discard_const_p(char *, kwnames),
    5713             :                 &blob.data, &blob_length,
    5714             :                 &bigendian_obj,
    5715             :                 &ndr64_obj,
    5716             :                 &allow_remaining_obj)) {
    5717           0 :                 return NULL;
    5718             :         }
    5719           0 :         blob.length = blob_length;
    5720             : 
    5721           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    5722           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    5723             :         }
    5724           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    5725           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    5726             :         }
    5727             : 
    5728           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    5729           0 :                 allow_remaining = true;
    5730             :         }
    5731             : 
    5732           0 :         return py_smbsrv_information_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
    5733             : }
    5734             : 
    5735           0 : static PyObject *py_smbsrv_information_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    5736             : {
    5737             :         DATA_BLOB blob;
    5738           0 :         Py_ssize_t blob_length = 0;
    5739           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    5740           0 :         PyObject *bigendian_obj = NULL;
    5741           0 :         PyObject *ndr64_obj = NULL;
    5742           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    5743           0 :         PyObject *allow_remaining_obj = NULL;
    5744           0 :         bool allow_remaining = false;
    5745             : 
    5746           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
    5747             :                 discard_const_p(char *, kwnames),
    5748             :                 &blob.data, &blob_length,
    5749             :                 &bigendian_obj,
    5750             :                 &ndr64_obj,
    5751             :                 &allow_remaining_obj)) {
    5752           0 :                 return NULL;
    5753             :         }
    5754           0 :         blob.length = blob_length;
    5755             : 
    5756           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    5757           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    5758             :         }
    5759           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    5760           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    5761             :         }
    5762             : 
    5763           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    5764           0 :                 allow_remaining = true;
    5765             :         }
    5766             : 
    5767           0 :         return py_smbsrv_information_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
    5768             : }
    5769             : 
    5770           0 : static PyObject *py_smbsrv_information_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
    5771             : {
    5772           0 :         const struct ndr_interface_call *call = NULL;
    5773           0 :         struct smbsrv_information *object = pytalloc_get_ptr(py_obj);
    5774             :         PyObject *ret;
    5775             :         char *retstr;
    5776             : 
    5777           0 :         if (ndr_table_irpc.num_calls < 7) {
    5778           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_smbsrv_information_ndr_print");
    5779           0 :                 return NULL;
    5780             :         }
    5781           0 :         call = &ndr_table_irpc.calls[6];
    5782             : 
    5783           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
    5784           0 :         ret = PyUnicode_FromString(retstr);
    5785           0 :         TALLOC_FREE(retstr);
    5786             : 
    5787           0 :         return ret;
    5788             : }
    5789             : 
    5790           0 : static PyObject *py_smbsrv_information_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    5791             : {
    5792           0 :         return py_smbsrv_information_ndr_print(py_obj, "smbsrv_information_in", NDR_IN);
    5793             : }
    5794             : 
    5795           0 : static PyObject *py_smbsrv_information_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    5796             : {
    5797           0 :         return py_smbsrv_information_ndr_print(py_obj, "smbsrv_information_out", NDR_OUT);
    5798             : }
    5799             : 
    5800             : static PyMethodDef py_smbsrv_information_methods[] = {
    5801             :         { "opnum", (PyCFunction)py_smbsrv_information_ndr_opnum, METH_NOARGS|METH_CLASS,
    5802             :                 "irpc.smbsrv_information.opnum() -> 6 (0x06) " },
    5803             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_smbsrv_information_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
    5804             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
    5805             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_smbsrv_information_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
    5806             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
    5807             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_smbsrv_information_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
    5808             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
    5809             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_smbsrv_information_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
    5810             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
    5811             :         { "__ndr_print_in__", (PyCFunction)py_smbsrv_information_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
    5812             :         { "__ndr_print_out__", (PyCFunction)py_smbsrv_information_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
    5813             :         { NULL, NULL, 0, NULL }
    5814             : };
    5815             : 
    5816             : 
    5817             : static PyTypeObject smbsrv_information_Type = {
    5818             :         PyVarObject_HEAD_INIT(NULL, 0)
    5819             :         .tp_name = "irpc.smbsrv_information",
    5820             :         .tp_getset = py_smbsrv_information_getsetters,
    5821             :         .tp_methods = py_smbsrv_information_methods,
    5822             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    5823             :         .tp_new = py_smbsrv_information_new,
    5824             : };
    5825             : 
    5826           0 : static bool pack_py_smbsrv_information_args_in(PyObject *args, PyObject *kwargs, struct smbsrv_information *r)
    5827             : {
    5828             :         PyObject *py_level;
    5829           0 :         const char *kwnames[] = {
    5830             :                 "level", NULL
    5831             :         };
    5832             : 
    5833           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:smbsrv_information", discard_const_p(char *, kwnames), &py_level)) {
    5834           0 :                 return false;
    5835             :         }
    5836             : 
    5837           0 :         if (py_level == NULL) {
    5838           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.level");
    5839           0 :                 return false;
    5840             :         }
    5841             :         {
    5842           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.level));
    5843           0 :                 if (PyLong_Check(py_level)) {
    5844             :                         unsigned long long test_var;
    5845           0 :                         test_var = PyLong_AsUnsignedLongLong(py_level);
    5846           0 :                         if (PyErr_Occurred() != NULL) {
    5847           0 :                                 return false;
    5848             :                         }
    5849           0 :                         if (test_var > uint_max) {
    5850           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    5851             :                                   PyLong_Type.tp_name, uint_max, test_var);
    5852           0 :                                 return false;
    5853             :                         }
    5854           0 :                         r->in.level = test_var;
    5855             :                 } else {
    5856           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    5857             :                           PyLong_Type.tp_name);
    5858           0 :                         return false;
    5859             :                 }
    5860             :         }
    5861           0 :         return true;
    5862             : }
    5863             : 
    5864           0 : static PyObject *unpack_py_smbsrv_information_args_out(struct smbsrv_information *r)
    5865             : {
    5866             :         PyObject *result;
    5867             :         PyObject *py_info;
    5868           0 :         py_info = pyrpc_import_union(&smbsrv_info_Type, r, r->in.level, &r->out.info, "union smbsrv_info");
    5869           0 :         if (py_info == NULL) {
    5870           0 :                 return NULL;
    5871             :         }
    5872           0 :         result = py_info;
    5873           0 :         return result;
    5874             : }
    5875             : 
    5876             : 
    5877           0 : static PyObject *py_samba_terminate_in_get_reason(PyObject *obj, void *closure)
    5878             : {
    5879           0 :         struct samba_terminate *object = pytalloc_get_ptr(obj);
    5880             :         PyObject *py_reason;
    5881           0 :         py_reason = PyString_FromStringOrNULL(object->in.reason);
    5882           0 :         return py_reason;
    5883             : }
    5884             : 
    5885           0 : static int py_samba_terminate_in_set_reason(PyObject *py_obj, PyObject *value, void *closure)
    5886             : {
    5887           0 :         struct samba_terminate *object = pytalloc_get_ptr(py_obj);
    5888           0 :         if (value == NULL) {
    5889           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.reason");
    5890           0 :                 return -1;
    5891             :         }
    5892             :         {
    5893             :                 const char *test_str;
    5894             :                 const char *talloc_str;
    5895           0 :                 PyObject *unicode = NULL;
    5896           0 :                 if (PyUnicode_Check(value)) {
    5897           0 :                         unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    5898           0 :                         if (unicode == NULL) {
    5899           0 :                                 return -1;
    5900             :                         }
    5901           0 :                         test_str = PyBytes_AS_STRING(unicode);
    5902           0 :                 } else if (PyBytes_Check(value)) {
    5903           0 :                         test_str = PyBytes_AS_STRING(value);
    5904             :                 } else {
    5905           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    5906           0 :                         return -1;
    5907             :                 }
    5908           0 :                 talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    5909           0 :                 if (unicode != NULL) {
    5910           0 :                         Py_DECREF(unicode);
    5911             :                 }
    5912           0 :                 if (talloc_str == NULL) {
    5913           0 :                         PyErr_NoMemory();
    5914           0 :                         return -1;
    5915             :                 }
    5916           0 :                 object->in.reason = talloc_str;
    5917             :         }
    5918           0 :         return 0;
    5919             : }
    5920             : 
    5921             : static PyGetSetDef py_samba_terminate_getsetters[] = {
    5922             :         {
    5923             :                 .name = discard_const_p(char, "in_reason"),
    5924             :                 .get = py_samba_terminate_in_get_reason,
    5925             :                 .set = py_samba_terminate_in_set_reason,
    5926             :                 .doc = discard_const_p(char, "PIDL-generated element of base type string")
    5927             :         },
    5928             :         { .name = NULL }
    5929             : };
    5930             : 
    5931           0 : static PyObject *py_samba_terminate_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    5932             : {
    5933           0 :         PyObject *self = pytalloc_new(struct samba_terminate, type);
    5934           0 :         return self;
    5935             : }
    5936             : 
    5937           0 : static PyObject *py_samba_terminate_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
    5938             : {
    5939             : 
    5940             : 
    5941           0 :         return PyLong_FromLong(7);
    5942             : }
    5943             : 
    5944           0 : static PyObject *py_samba_terminate_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
    5945             : {
    5946           0 :         const struct ndr_interface_call *call = NULL;
    5947           0 :         struct samba_terminate *object = pytalloc_get_ptr(py_obj);
    5948           0 :         PyObject *ret = NULL;
    5949           0 :         struct ndr_push *push = NULL;
    5950             :         DATA_BLOB blob;
    5951             :         enum ndr_err_code err;
    5952             : 
    5953           0 :         if (ndr_table_irpc.num_calls < 8) {
    5954           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_samba_terminate_ndr_pack");
    5955           0 :                 return NULL;
    5956             :         }
    5957           0 :         call = &ndr_table_irpc.calls[7];
    5958             : 
    5959           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
    5960           0 :         if (push == NULL) {
    5961           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    5962           0 :                 return NULL;
    5963             :         }
    5964             : 
    5965           0 :         push->flags |= ndr_push_flags;
    5966             : 
    5967           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
    5968           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    5969           0 :                 TALLOC_FREE(push);
    5970           0 :                 PyErr_SetNdrError(err);
    5971           0 :                 return NULL;
    5972             :         }
    5973           0 :         blob = ndr_push_blob(push);
    5974           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
    5975           0 :         TALLOC_FREE(push);
    5976           0 :         return ret;
    5977             : }
    5978             : 
    5979           0 : static PyObject *py_samba_terminate_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    5980             : {
    5981           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    5982           0 :         PyObject *bigendian_obj = NULL;
    5983           0 :         PyObject *ndr64_obj = NULL;
    5984           0 :         libndr_flags ndr_push_flags = 0;
    5985             : 
    5986           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
    5987             :                 discard_const_p(char *, kwnames),
    5988             :                 &bigendian_obj,
    5989             :                 &ndr64_obj)) {
    5990           0 :                 return NULL;
    5991             :         }
    5992             : 
    5993           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    5994           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    5995             :         }
    5996           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    5997           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    5998             :         }
    5999             : 
    6000           0 :         return py_samba_terminate_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
    6001             : }
    6002             : 
    6003           0 : static PyObject *py_samba_terminate_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    6004             : {
    6005           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    6006           0 :         PyObject *bigendian_obj = NULL;
    6007           0 :         PyObject *ndr64_obj = NULL;
    6008           0 :         libndr_flags ndr_push_flags = 0;
    6009             : 
    6010           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
    6011             :                 discard_const_p(char *, kwnames),
    6012             :                 &bigendian_obj,
    6013             :                 &ndr64_obj)) {
    6014           0 :                 return NULL;
    6015             :         }
    6016             : 
    6017           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    6018           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    6019             :         }
    6020           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    6021           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    6022             :         }
    6023             : 
    6024           0 :         return py_samba_terminate_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
    6025             : }
    6026             : 
    6027           0 : static PyObject *py_samba_terminate_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
    6028             : {
    6029           0 :         const struct ndr_interface_call *call = NULL;
    6030           0 :         struct samba_terminate *object = pytalloc_get_ptr(py_obj);
    6031           0 :         struct ndr_pull *pull = NULL;
    6032             :         enum ndr_err_code err;
    6033             : 
    6034           0 :         if (ndr_table_irpc.num_calls < 8) {
    6035           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_samba_terminate_ndr_unpack");
    6036           0 :                 return NULL;
    6037             :         }
    6038           0 :         call = &ndr_table_irpc.calls[7];
    6039             : 
    6040           0 :         pull = ndr_pull_init_blob(blob, object);
    6041           0 :         if (pull == NULL) {
    6042           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    6043           0 :                 return NULL;
    6044             :         }
    6045             : 
    6046           0 :         pull->flags |= ndr_pull_flags;
    6047             : 
    6048           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
    6049           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    6050           0 :                 TALLOC_FREE(pull);
    6051           0 :                 PyErr_SetNdrError(err);
    6052           0 :                 return NULL;
    6053             :         }
    6054           0 :         if (!allow_remaining) {
    6055             :                 uint32_t highest_ofs;
    6056             : 
    6057           0 :                 if (pull->offset > pull->relative_highest_offset) {
    6058           0 :                         highest_ofs = pull->offset;
    6059             :                 } else {
    6060           0 :                         highest_ofs = pull->relative_highest_offset;
    6061             :                 }
    6062           0 :                 if (highest_ofs < pull->data_size) {
    6063           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
    6064             :                                 "not all bytes consumed ofs[%u] size[%u]",
    6065             :                                 highest_ofs, pull->data_size);
    6066           0 :                         TALLOC_FREE(pull);
    6067           0 :                         PyErr_SetNdrError(err);
    6068           0 :                         return NULL;
    6069             :                 }
    6070             :         }
    6071             : 
    6072           0 :         TALLOC_FREE(pull);
    6073           0 :         Py_RETURN_NONE;
    6074             : }
    6075             : 
    6076           0 : static PyObject *py_samba_terminate_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    6077             : {
    6078             :         DATA_BLOB blob;
    6079           0 :         Py_ssize_t blob_length = 0;
    6080           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    6081           0 :         PyObject *bigendian_obj = NULL;
    6082           0 :         PyObject *ndr64_obj = NULL;
    6083           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    6084           0 :         PyObject *allow_remaining_obj = NULL;
    6085           0 :         bool allow_remaining = false;
    6086             : 
    6087           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
    6088             :                 discard_const_p(char *, kwnames),
    6089             :                 &blob.data, &blob_length,
    6090             :                 &bigendian_obj,
    6091             :                 &ndr64_obj,
    6092             :                 &allow_remaining_obj)) {
    6093           0 :                 return NULL;
    6094             :         }
    6095           0 :         blob.length = blob_length;
    6096             : 
    6097           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    6098           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    6099             :         }
    6100           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    6101           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    6102             :         }
    6103             : 
    6104           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    6105           0 :                 allow_remaining = true;
    6106             :         }
    6107             : 
    6108           0 :         return py_samba_terminate_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
    6109             : }
    6110             : 
    6111           0 : static PyObject *py_samba_terminate_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    6112             : {
    6113             :         DATA_BLOB blob;
    6114           0 :         Py_ssize_t blob_length = 0;
    6115           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    6116           0 :         PyObject *bigendian_obj = NULL;
    6117           0 :         PyObject *ndr64_obj = NULL;
    6118           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    6119           0 :         PyObject *allow_remaining_obj = NULL;
    6120           0 :         bool allow_remaining = false;
    6121             : 
    6122           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
    6123             :                 discard_const_p(char *, kwnames),
    6124             :                 &blob.data, &blob_length,
    6125             :                 &bigendian_obj,
    6126             :                 &ndr64_obj,
    6127             :                 &allow_remaining_obj)) {
    6128           0 :                 return NULL;
    6129             :         }
    6130           0 :         blob.length = blob_length;
    6131             : 
    6132           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    6133           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    6134             :         }
    6135           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    6136           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    6137             :         }
    6138             : 
    6139           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    6140           0 :                 allow_remaining = true;
    6141             :         }
    6142             : 
    6143           0 :         return py_samba_terminate_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
    6144             : }
    6145             : 
    6146           0 : static PyObject *py_samba_terminate_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
    6147             : {
    6148           0 :         const struct ndr_interface_call *call = NULL;
    6149           0 :         struct samba_terminate *object = pytalloc_get_ptr(py_obj);
    6150             :         PyObject *ret;
    6151             :         char *retstr;
    6152             : 
    6153           0 :         if (ndr_table_irpc.num_calls < 8) {
    6154           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_samba_terminate_ndr_print");
    6155           0 :                 return NULL;
    6156             :         }
    6157           0 :         call = &ndr_table_irpc.calls[7];
    6158             : 
    6159           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
    6160           0 :         ret = PyUnicode_FromString(retstr);
    6161           0 :         TALLOC_FREE(retstr);
    6162             : 
    6163           0 :         return ret;
    6164             : }
    6165             : 
    6166           0 : static PyObject *py_samba_terminate_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    6167             : {
    6168           0 :         return py_samba_terminate_ndr_print(py_obj, "samba_terminate_in", NDR_IN);
    6169             : }
    6170             : 
    6171           0 : static PyObject *py_samba_terminate_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    6172             : {
    6173           0 :         return py_samba_terminate_ndr_print(py_obj, "samba_terminate_out", NDR_OUT);
    6174             : }
    6175             : 
    6176             : static PyMethodDef py_samba_terminate_methods[] = {
    6177             :         { "opnum", (PyCFunction)py_samba_terminate_ndr_opnum, METH_NOARGS|METH_CLASS,
    6178             :                 "irpc.samba_terminate.opnum() -> 7 (0x07) " },
    6179             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_samba_terminate_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
    6180             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
    6181             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_samba_terminate_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
    6182             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
    6183             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_samba_terminate_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
    6184             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
    6185             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_samba_terminate_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
    6186             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
    6187             :         { "__ndr_print_in__", (PyCFunction)py_samba_terminate_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
    6188             :         { "__ndr_print_out__", (PyCFunction)py_samba_terminate_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
    6189             :         { NULL, NULL, 0, NULL }
    6190             : };
    6191             : 
    6192             : 
    6193             : static PyTypeObject samba_terminate_Type = {
    6194             :         PyVarObject_HEAD_INIT(NULL, 0)
    6195             :         .tp_name = "irpc.samba_terminate",
    6196             :         .tp_getset = py_samba_terminate_getsetters,
    6197             :         .tp_methods = py_samba_terminate_methods,
    6198             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    6199             :         .tp_new = py_samba_terminate_new,
    6200             : };
    6201             : 
    6202           0 : static bool pack_py_samba_terminate_args_in(PyObject *args, PyObject *kwargs, struct samba_terminate *r)
    6203             : {
    6204             :         PyObject *py_reason;
    6205           0 :         const char *kwnames[] = {
    6206             :                 "reason", NULL
    6207             :         };
    6208             : 
    6209           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:samba_terminate", discard_const_p(char *, kwnames), &py_reason)) {
    6210           0 :                 return false;
    6211             :         }
    6212             : 
    6213           0 :         if (py_reason == NULL) {
    6214           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.reason");
    6215           0 :                 return false;
    6216             :         }
    6217             :         {
    6218             :                 const char *test_str;
    6219             :                 const char *talloc_str;
    6220           0 :                 PyObject *unicode = NULL;
    6221           0 :                 if (PyUnicode_Check(py_reason)) {
    6222           0 :                         unicode = PyUnicode_AsEncodedString(py_reason, "utf-8", "ignore");
    6223           0 :                         if (unicode == NULL) {
    6224           0 :                                 return false;
    6225             :                         }
    6226           0 :                         test_str = PyBytes_AS_STRING(unicode);
    6227           0 :                 } else if (PyBytes_Check(py_reason)) {
    6228           0 :                         test_str = PyBytes_AS_STRING(py_reason);
    6229             :                 } else {
    6230           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_reason)->tp_name);
    6231           0 :                         return false;
    6232             :                 }
    6233           0 :                 talloc_str = talloc_strdup(r, test_str);
    6234           0 :                 if (unicode != NULL) {
    6235           0 :                         Py_DECREF(unicode);
    6236             :                 }
    6237           0 :                 if (talloc_str == NULL) {
    6238           0 :                         PyErr_NoMemory();
    6239           0 :                         return false;
    6240             :                 }
    6241           0 :                 r->in.reason = talloc_str;
    6242             :         }
    6243           0 :         return true;
    6244             : }
    6245             : 
    6246           0 : static PyObject *unpack_py_samba_terminate_args_out(struct samba_terminate *r)
    6247             : {
    6248             :         PyObject *result;
    6249           0 :         result = Py_None;
    6250           0 :         Py_INCREF(result);
    6251           0 :         return result;
    6252             : }
    6253             : 
    6254             : 
    6255           0 : static PyObject *py_dreplsrv_refresh_get_result(PyObject *obj, void *closure)
    6256             : {
    6257           0 :         struct dreplsrv_refresh *object = pytalloc_get_ptr(obj);
    6258             :         PyObject *py_result;
    6259           0 :         py_result = PyErr_FromWERROR(object->out.result);
    6260           0 :         return py_result;
    6261             : }
    6262             : 
    6263           0 : static int py_dreplsrv_refresh_set_result(PyObject *py_obj, PyObject *value, void *closure)
    6264             : {
    6265           0 :         struct dreplsrv_refresh *object = pytalloc_get_ptr(py_obj);
    6266           0 :         if (value == NULL) {
    6267           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.result");
    6268           0 :                 return -1;
    6269             :         }
    6270           0 :         object->out.result = W_ERROR(PyLong_AsLong(value));
    6271           0 :         return 0;
    6272             : }
    6273             : 
    6274             : static PyGetSetDef py_dreplsrv_refresh_getsetters[] = {
    6275             :         {
    6276             :                 .name = discard_const_p(char, "result"),
    6277             :                 .get = py_dreplsrv_refresh_get_result,
    6278             :                 .set = py_dreplsrv_refresh_set_result,
    6279             :                 .doc = discard_const_p(char, "PIDL-generated element of type WERROR")
    6280             :         },
    6281             :         { .name = NULL }
    6282             : };
    6283             : 
    6284           0 : static PyObject *py_dreplsrv_refresh_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    6285             : {
    6286           0 :         PyObject *self = pytalloc_new(struct dreplsrv_refresh, type);
    6287           0 :         return self;
    6288             : }
    6289             : 
    6290           0 : static PyObject *py_dreplsrv_refresh_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
    6291             : {
    6292             : 
    6293             : 
    6294           0 :         return PyLong_FromLong(8);
    6295             : }
    6296             : 
    6297           0 : static PyObject *py_dreplsrv_refresh_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
    6298             : {
    6299           0 :         const struct ndr_interface_call *call = NULL;
    6300           0 :         struct dreplsrv_refresh *object = pytalloc_get_ptr(py_obj);
    6301           0 :         PyObject *ret = NULL;
    6302           0 :         struct ndr_push *push = NULL;
    6303             :         DATA_BLOB blob;
    6304             :         enum ndr_err_code err;
    6305             : 
    6306           0 :         if (ndr_table_irpc.num_calls < 9) {
    6307           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_dreplsrv_refresh_ndr_pack");
    6308           0 :                 return NULL;
    6309             :         }
    6310           0 :         call = &ndr_table_irpc.calls[8];
    6311             : 
    6312           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
    6313           0 :         if (push == NULL) {
    6314           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    6315           0 :                 return NULL;
    6316             :         }
    6317             : 
    6318           0 :         push->flags |= ndr_push_flags;
    6319             : 
    6320           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
    6321           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    6322           0 :                 TALLOC_FREE(push);
    6323           0 :                 PyErr_SetNdrError(err);
    6324           0 :                 return NULL;
    6325             :         }
    6326           0 :         blob = ndr_push_blob(push);
    6327           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
    6328           0 :         TALLOC_FREE(push);
    6329           0 :         return ret;
    6330             : }
    6331             : 
    6332           0 : static PyObject *py_dreplsrv_refresh_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    6333             : {
    6334           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    6335           0 :         PyObject *bigendian_obj = NULL;
    6336           0 :         PyObject *ndr64_obj = NULL;
    6337           0 :         libndr_flags ndr_push_flags = 0;
    6338             : 
    6339           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
    6340             :                 discard_const_p(char *, kwnames),
    6341             :                 &bigendian_obj,
    6342             :                 &ndr64_obj)) {
    6343           0 :                 return NULL;
    6344             :         }
    6345             : 
    6346           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    6347           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    6348             :         }
    6349           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    6350           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    6351             :         }
    6352             : 
    6353           0 :         return py_dreplsrv_refresh_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
    6354             : }
    6355             : 
    6356           0 : static PyObject *py_dreplsrv_refresh_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    6357             : {
    6358           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    6359           0 :         PyObject *bigendian_obj = NULL;
    6360           0 :         PyObject *ndr64_obj = NULL;
    6361           0 :         libndr_flags ndr_push_flags = 0;
    6362             : 
    6363           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
    6364             :                 discard_const_p(char *, kwnames),
    6365             :                 &bigendian_obj,
    6366             :                 &ndr64_obj)) {
    6367           0 :                 return NULL;
    6368             :         }
    6369             : 
    6370           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    6371           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    6372             :         }
    6373           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    6374           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    6375             :         }
    6376             : 
    6377           0 :         return py_dreplsrv_refresh_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
    6378             : }
    6379             : 
    6380           0 : static PyObject *py_dreplsrv_refresh_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
    6381             : {
    6382           0 :         const struct ndr_interface_call *call = NULL;
    6383           0 :         struct dreplsrv_refresh *object = pytalloc_get_ptr(py_obj);
    6384           0 :         struct ndr_pull *pull = NULL;
    6385             :         enum ndr_err_code err;
    6386             : 
    6387           0 :         if (ndr_table_irpc.num_calls < 9) {
    6388           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_dreplsrv_refresh_ndr_unpack");
    6389           0 :                 return NULL;
    6390             :         }
    6391           0 :         call = &ndr_table_irpc.calls[8];
    6392             : 
    6393           0 :         pull = ndr_pull_init_blob(blob, object);
    6394           0 :         if (pull == NULL) {
    6395           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    6396           0 :                 return NULL;
    6397             :         }
    6398             : 
    6399           0 :         pull->flags |= ndr_pull_flags;
    6400             : 
    6401           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
    6402           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    6403           0 :                 TALLOC_FREE(pull);
    6404           0 :                 PyErr_SetNdrError(err);
    6405           0 :                 return NULL;
    6406             :         }
    6407           0 :         if (!allow_remaining) {
    6408             :                 uint32_t highest_ofs;
    6409             : 
    6410           0 :                 if (pull->offset > pull->relative_highest_offset) {
    6411           0 :                         highest_ofs = pull->offset;
    6412             :                 } else {
    6413           0 :                         highest_ofs = pull->relative_highest_offset;
    6414             :                 }
    6415           0 :                 if (highest_ofs < pull->data_size) {
    6416           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
    6417             :                                 "not all bytes consumed ofs[%u] size[%u]",
    6418             :                                 highest_ofs, pull->data_size);
    6419           0 :                         TALLOC_FREE(pull);
    6420           0 :                         PyErr_SetNdrError(err);
    6421           0 :                         return NULL;
    6422             :                 }
    6423             :         }
    6424             : 
    6425           0 :         TALLOC_FREE(pull);
    6426           0 :         Py_RETURN_NONE;
    6427             : }
    6428             : 
    6429           0 : static PyObject *py_dreplsrv_refresh_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    6430             : {
    6431             :         DATA_BLOB blob;
    6432           0 :         Py_ssize_t blob_length = 0;
    6433           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    6434           0 :         PyObject *bigendian_obj = NULL;
    6435           0 :         PyObject *ndr64_obj = NULL;
    6436           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    6437           0 :         PyObject *allow_remaining_obj = NULL;
    6438           0 :         bool allow_remaining = false;
    6439             : 
    6440           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
    6441             :                 discard_const_p(char *, kwnames),
    6442             :                 &blob.data, &blob_length,
    6443             :                 &bigendian_obj,
    6444             :                 &ndr64_obj,
    6445             :                 &allow_remaining_obj)) {
    6446           0 :                 return NULL;
    6447             :         }
    6448           0 :         blob.length = blob_length;
    6449             : 
    6450           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    6451           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    6452             :         }
    6453           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    6454           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    6455             :         }
    6456             : 
    6457           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    6458           0 :                 allow_remaining = true;
    6459             :         }
    6460             : 
    6461           0 :         return py_dreplsrv_refresh_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
    6462             : }
    6463             : 
    6464           0 : static PyObject *py_dreplsrv_refresh_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    6465             : {
    6466             :         DATA_BLOB blob;
    6467           0 :         Py_ssize_t blob_length = 0;
    6468           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    6469           0 :         PyObject *bigendian_obj = NULL;
    6470           0 :         PyObject *ndr64_obj = NULL;
    6471           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    6472           0 :         PyObject *allow_remaining_obj = NULL;
    6473           0 :         bool allow_remaining = false;
    6474             : 
    6475           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
    6476             :                 discard_const_p(char *, kwnames),
    6477             :                 &blob.data, &blob_length,
    6478             :                 &bigendian_obj,
    6479             :                 &ndr64_obj,
    6480             :                 &allow_remaining_obj)) {
    6481           0 :                 return NULL;
    6482             :         }
    6483           0 :         blob.length = blob_length;
    6484             : 
    6485           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    6486           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    6487             :         }
    6488           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    6489           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    6490             :         }
    6491             : 
    6492           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    6493           0 :                 allow_remaining = true;
    6494             :         }
    6495             : 
    6496           0 :         return py_dreplsrv_refresh_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
    6497             : }
    6498             : 
    6499           0 : static PyObject *py_dreplsrv_refresh_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
    6500             : {
    6501           0 :         const struct ndr_interface_call *call = NULL;
    6502           0 :         struct dreplsrv_refresh *object = pytalloc_get_ptr(py_obj);
    6503             :         PyObject *ret;
    6504             :         char *retstr;
    6505             : 
    6506           0 :         if (ndr_table_irpc.num_calls < 9) {
    6507           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_dreplsrv_refresh_ndr_print");
    6508           0 :                 return NULL;
    6509             :         }
    6510           0 :         call = &ndr_table_irpc.calls[8];
    6511             : 
    6512           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
    6513           0 :         ret = PyUnicode_FromString(retstr);
    6514           0 :         TALLOC_FREE(retstr);
    6515             : 
    6516           0 :         return ret;
    6517             : }
    6518             : 
    6519           0 : static PyObject *py_dreplsrv_refresh_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    6520             : {
    6521           0 :         return py_dreplsrv_refresh_ndr_print(py_obj, "dreplsrv_refresh_in", NDR_IN);
    6522             : }
    6523             : 
    6524           0 : static PyObject *py_dreplsrv_refresh_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    6525             : {
    6526           0 :         return py_dreplsrv_refresh_ndr_print(py_obj, "dreplsrv_refresh_out", NDR_OUT);
    6527             : }
    6528             : 
    6529             : static PyMethodDef py_dreplsrv_refresh_methods[] = {
    6530             :         { "opnum", (PyCFunction)py_dreplsrv_refresh_ndr_opnum, METH_NOARGS|METH_CLASS,
    6531             :                 "irpc.dreplsrv_refresh.opnum() -> 8 (0x08) " },
    6532             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_dreplsrv_refresh_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
    6533             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
    6534             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_dreplsrv_refresh_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
    6535             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
    6536             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_dreplsrv_refresh_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
    6537             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
    6538             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_dreplsrv_refresh_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
    6539             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
    6540             :         { "__ndr_print_in__", (PyCFunction)py_dreplsrv_refresh_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
    6541             :         { "__ndr_print_out__", (PyCFunction)py_dreplsrv_refresh_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
    6542             :         { NULL, NULL, 0, NULL }
    6543             : };
    6544             : 
    6545             : 
    6546             : static PyTypeObject dreplsrv_refresh_Type = {
    6547             :         PyVarObject_HEAD_INIT(NULL, 0)
    6548             :         .tp_name = "irpc.dreplsrv_refresh",
    6549             :         .tp_getset = py_dreplsrv_refresh_getsetters,
    6550             :         .tp_methods = py_dreplsrv_refresh_methods,
    6551             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    6552             :         .tp_new = py_dreplsrv_refresh_new,
    6553             : };
    6554             : 
    6555           0 : static bool pack_py_dreplsrv_refresh_args_in(PyObject *args, PyObject *kwargs, struct dreplsrv_refresh *r)
    6556             : {
    6557           0 :         const char *kwnames[] = {
    6558             :                 NULL
    6559             :         };
    6560             : 
    6561           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, ":dreplsrv_refresh", discard_const_p(char *, kwnames))) {
    6562           0 :                 return false;
    6563             :         }
    6564             : 
    6565           0 :         return true;
    6566             : }
    6567             : 
    6568           0 : static PyObject *unpack_py_dreplsrv_refresh_args_out(struct dreplsrv_refresh *r)
    6569             : {
    6570             :         PyObject *result;
    6571           0 :         result = Py_None;
    6572           0 :         Py_INCREF(result);
    6573           0 :         if (!W_ERROR_IS_OK(r->out.result)) {
    6574           0 :                 PyErr_SetWERROR(r->out.result);
    6575           0 :                 return NULL;
    6576             :         }
    6577             : 
    6578           0 :         return result;
    6579             : }
    6580             : 
    6581             : 
    6582           0 : static PyObject *py_drepl_takeFSMORole_in_get_role(PyObject *obj, void *closure)
    6583             : {
    6584           0 :         struct drepl_takeFSMORole *object = pytalloc_get_ptr(obj);
    6585             :         PyObject *py_role;
    6586           0 :         py_role = PyLong_FromUnsignedLongLong((uint32_t)(object->in.role));
    6587           0 :         return py_role;
    6588             : }
    6589             : 
    6590           0 : static int py_drepl_takeFSMORole_in_set_role(PyObject *py_obj, PyObject *value, void *closure)
    6591             : {
    6592           0 :         struct drepl_takeFSMORole *object = pytalloc_get_ptr(py_obj);
    6593           0 :         if (value == NULL) {
    6594           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.role");
    6595           0 :                 return -1;
    6596             :         }
    6597             :         {
    6598           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.role));
    6599           0 :                 if (PyLong_Check(value)) {
    6600             :                         unsigned long long test_var;
    6601           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    6602           0 :                         if (PyErr_Occurred() != NULL) {
    6603           0 :                                 return -1;
    6604             :                         }
    6605           0 :                         if (test_var > uint_max) {
    6606           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    6607             :                                   PyLong_Type.tp_name, uint_max, test_var);
    6608           0 :                                 return -1;
    6609             :                         }
    6610           0 :                         object->in.role = test_var;
    6611             :                 } else {
    6612           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    6613             :                           PyLong_Type.tp_name);
    6614           0 :                         return -1;
    6615             :                 }
    6616             :         }
    6617           0 :         return 0;
    6618             : }
    6619             : 
    6620           0 : static PyObject *py_drepl_takeFSMORole_get_result(PyObject *obj, void *closure)
    6621             : {
    6622           0 :         struct drepl_takeFSMORole *object = pytalloc_get_ptr(obj);
    6623             :         PyObject *py_result;
    6624           0 :         py_result = PyErr_FromWERROR(object->out.result);
    6625           0 :         return py_result;
    6626             : }
    6627             : 
    6628           0 : static int py_drepl_takeFSMORole_set_result(PyObject *py_obj, PyObject *value, void *closure)
    6629             : {
    6630           0 :         struct drepl_takeFSMORole *object = pytalloc_get_ptr(py_obj);
    6631           0 :         if (value == NULL) {
    6632           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.result");
    6633           0 :                 return -1;
    6634             :         }
    6635           0 :         object->out.result = W_ERROR(PyLong_AsLong(value));
    6636           0 :         return 0;
    6637             : }
    6638             : 
    6639             : static PyGetSetDef py_drepl_takeFSMORole_getsetters[] = {
    6640             :         {
    6641             :                 .name = discard_const_p(char, "in_role"),
    6642             :                 .get = py_drepl_takeFSMORole_in_get_role,
    6643             :                 .set = py_drepl_takeFSMORole_in_set_role,
    6644             :                 .doc = discard_const_p(char, "PIDL-generated element of base type drepl_role_master")
    6645             :         },
    6646             :         {
    6647             :                 .name = discard_const_p(char, "result"),
    6648             :                 .get = py_drepl_takeFSMORole_get_result,
    6649             :                 .set = py_drepl_takeFSMORole_set_result,
    6650             :                 .doc = discard_const_p(char, "PIDL-generated element of type WERROR")
    6651             :         },
    6652             :         { .name = NULL }
    6653             : };
    6654             : 
    6655           0 : static PyObject *py_drepl_takeFSMORole_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    6656             : {
    6657           0 :         PyObject *self = pytalloc_new(struct drepl_takeFSMORole, type);
    6658           0 :         return self;
    6659             : }
    6660             : 
    6661           0 : static PyObject *py_drepl_takeFSMORole_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
    6662             : {
    6663             : 
    6664             : 
    6665           0 :         return PyLong_FromLong(9);
    6666             : }
    6667             : 
    6668           0 : static PyObject *py_drepl_takeFSMORole_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
    6669             : {
    6670           0 :         const struct ndr_interface_call *call = NULL;
    6671           0 :         struct drepl_takeFSMORole *object = pytalloc_get_ptr(py_obj);
    6672           0 :         PyObject *ret = NULL;
    6673           0 :         struct ndr_push *push = NULL;
    6674             :         DATA_BLOB blob;
    6675             :         enum ndr_err_code err;
    6676             : 
    6677           0 :         if (ndr_table_irpc.num_calls < 10) {
    6678           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_drepl_takeFSMORole_ndr_pack");
    6679           0 :                 return NULL;
    6680             :         }
    6681           0 :         call = &ndr_table_irpc.calls[9];
    6682             : 
    6683           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
    6684           0 :         if (push == NULL) {
    6685           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    6686           0 :                 return NULL;
    6687             :         }
    6688             : 
    6689           0 :         push->flags |= ndr_push_flags;
    6690             : 
    6691           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
    6692           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    6693           0 :                 TALLOC_FREE(push);
    6694           0 :                 PyErr_SetNdrError(err);
    6695           0 :                 return NULL;
    6696             :         }
    6697           0 :         blob = ndr_push_blob(push);
    6698           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
    6699           0 :         TALLOC_FREE(push);
    6700           0 :         return ret;
    6701             : }
    6702             : 
    6703           0 : static PyObject *py_drepl_takeFSMORole_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    6704             : {
    6705           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    6706           0 :         PyObject *bigendian_obj = NULL;
    6707           0 :         PyObject *ndr64_obj = NULL;
    6708           0 :         libndr_flags ndr_push_flags = 0;
    6709             : 
    6710           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
    6711             :                 discard_const_p(char *, kwnames),
    6712             :                 &bigendian_obj,
    6713             :                 &ndr64_obj)) {
    6714           0 :                 return NULL;
    6715             :         }
    6716             : 
    6717           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    6718           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    6719             :         }
    6720           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    6721           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    6722             :         }
    6723             : 
    6724           0 :         return py_drepl_takeFSMORole_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
    6725             : }
    6726             : 
    6727           0 : static PyObject *py_drepl_takeFSMORole_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    6728             : {
    6729           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    6730           0 :         PyObject *bigendian_obj = NULL;
    6731           0 :         PyObject *ndr64_obj = NULL;
    6732           0 :         libndr_flags ndr_push_flags = 0;
    6733             : 
    6734           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
    6735             :                 discard_const_p(char *, kwnames),
    6736             :                 &bigendian_obj,
    6737             :                 &ndr64_obj)) {
    6738           0 :                 return NULL;
    6739             :         }
    6740             : 
    6741           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    6742           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    6743             :         }
    6744           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    6745           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    6746             :         }
    6747             : 
    6748           0 :         return py_drepl_takeFSMORole_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
    6749             : }
    6750             : 
    6751           0 : static PyObject *py_drepl_takeFSMORole_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
    6752             : {
    6753           0 :         const struct ndr_interface_call *call = NULL;
    6754           0 :         struct drepl_takeFSMORole *object = pytalloc_get_ptr(py_obj);
    6755           0 :         struct ndr_pull *pull = NULL;
    6756             :         enum ndr_err_code err;
    6757             : 
    6758           0 :         if (ndr_table_irpc.num_calls < 10) {
    6759           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_drepl_takeFSMORole_ndr_unpack");
    6760           0 :                 return NULL;
    6761             :         }
    6762           0 :         call = &ndr_table_irpc.calls[9];
    6763             : 
    6764           0 :         pull = ndr_pull_init_blob(blob, object);
    6765           0 :         if (pull == NULL) {
    6766           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    6767           0 :                 return NULL;
    6768             :         }
    6769             : 
    6770           0 :         pull->flags |= ndr_pull_flags;
    6771             : 
    6772           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
    6773           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    6774           0 :                 TALLOC_FREE(pull);
    6775           0 :                 PyErr_SetNdrError(err);
    6776           0 :                 return NULL;
    6777             :         }
    6778           0 :         if (!allow_remaining) {
    6779             :                 uint32_t highest_ofs;
    6780             : 
    6781           0 :                 if (pull->offset > pull->relative_highest_offset) {
    6782           0 :                         highest_ofs = pull->offset;
    6783             :                 } else {
    6784           0 :                         highest_ofs = pull->relative_highest_offset;
    6785             :                 }
    6786           0 :                 if (highest_ofs < pull->data_size) {
    6787           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
    6788             :                                 "not all bytes consumed ofs[%u] size[%u]",
    6789             :                                 highest_ofs, pull->data_size);
    6790           0 :                         TALLOC_FREE(pull);
    6791           0 :                         PyErr_SetNdrError(err);
    6792           0 :                         return NULL;
    6793             :                 }
    6794             :         }
    6795             : 
    6796           0 :         TALLOC_FREE(pull);
    6797           0 :         Py_RETURN_NONE;
    6798             : }
    6799             : 
    6800           0 : static PyObject *py_drepl_takeFSMORole_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    6801             : {
    6802             :         DATA_BLOB blob;
    6803           0 :         Py_ssize_t blob_length = 0;
    6804           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    6805           0 :         PyObject *bigendian_obj = NULL;
    6806           0 :         PyObject *ndr64_obj = NULL;
    6807           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    6808           0 :         PyObject *allow_remaining_obj = NULL;
    6809           0 :         bool allow_remaining = false;
    6810             : 
    6811           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
    6812             :                 discard_const_p(char *, kwnames),
    6813             :                 &blob.data, &blob_length,
    6814             :                 &bigendian_obj,
    6815             :                 &ndr64_obj,
    6816             :                 &allow_remaining_obj)) {
    6817           0 :                 return NULL;
    6818             :         }
    6819           0 :         blob.length = blob_length;
    6820             : 
    6821           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    6822           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    6823             :         }
    6824           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    6825           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    6826             :         }
    6827             : 
    6828           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    6829           0 :                 allow_remaining = true;
    6830             :         }
    6831             : 
    6832           0 :         return py_drepl_takeFSMORole_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
    6833             : }
    6834             : 
    6835           0 : static PyObject *py_drepl_takeFSMORole_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    6836             : {
    6837             :         DATA_BLOB blob;
    6838           0 :         Py_ssize_t blob_length = 0;
    6839           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    6840           0 :         PyObject *bigendian_obj = NULL;
    6841           0 :         PyObject *ndr64_obj = NULL;
    6842           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    6843           0 :         PyObject *allow_remaining_obj = NULL;
    6844           0 :         bool allow_remaining = false;
    6845             : 
    6846           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
    6847             :                 discard_const_p(char *, kwnames),
    6848             :                 &blob.data, &blob_length,
    6849             :                 &bigendian_obj,
    6850             :                 &ndr64_obj,
    6851             :                 &allow_remaining_obj)) {
    6852           0 :                 return NULL;
    6853             :         }
    6854           0 :         blob.length = blob_length;
    6855             : 
    6856           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    6857           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    6858             :         }
    6859           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    6860           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    6861             :         }
    6862             : 
    6863           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    6864           0 :                 allow_remaining = true;
    6865             :         }
    6866             : 
    6867           0 :         return py_drepl_takeFSMORole_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
    6868             : }
    6869             : 
    6870           0 : static PyObject *py_drepl_takeFSMORole_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
    6871             : {
    6872           0 :         const struct ndr_interface_call *call = NULL;
    6873           0 :         struct drepl_takeFSMORole *object = pytalloc_get_ptr(py_obj);
    6874             :         PyObject *ret;
    6875             :         char *retstr;
    6876             : 
    6877           0 :         if (ndr_table_irpc.num_calls < 10) {
    6878           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_drepl_takeFSMORole_ndr_print");
    6879           0 :                 return NULL;
    6880             :         }
    6881           0 :         call = &ndr_table_irpc.calls[9];
    6882             : 
    6883           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
    6884           0 :         ret = PyUnicode_FromString(retstr);
    6885           0 :         TALLOC_FREE(retstr);
    6886             : 
    6887           0 :         return ret;
    6888             : }
    6889             : 
    6890           0 : static PyObject *py_drepl_takeFSMORole_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    6891             : {
    6892           0 :         return py_drepl_takeFSMORole_ndr_print(py_obj, "drepl_takeFSMORole_in", NDR_IN);
    6893             : }
    6894             : 
    6895           0 : static PyObject *py_drepl_takeFSMORole_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    6896             : {
    6897           0 :         return py_drepl_takeFSMORole_ndr_print(py_obj, "drepl_takeFSMORole_out", NDR_OUT);
    6898             : }
    6899             : 
    6900             : static PyMethodDef py_drepl_takeFSMORole_methods[] = {
    6901             :         { "opnum", (PyCFunction)py_drepl_takeFSMORole_ndr_opnum, METH_NOARGS|METH_CLASS,
    6902             :                 "irpc.drepl_takeFSMORole.opnum() -> 9 (0x09) " },
    6903             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_drepl_takeFSMORole_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
    6904             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
    6905             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_drepl_takeFSMORole_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
    6906             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
    6907             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_drepl_takeFSMORole_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
    6908             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
    6909             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_drepl_takeFSMORole_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
    6910             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
    6911             :         { "__ndr_print_in__", (PyCFunction)py_drepl_takeFSMORole_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
    6912             :         { "__ndr_print_out__", (PyCFunction)py_drepl_takeFSMORole_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
    6913             :         { NULL, NULL, 0, NULL }
    6914             : };
    6915             : 
    6916             : 
    6917             : static PyTypeObject drepl_takeFSMORole_Type = {
    6918             :         PyVarObject_HEAD_INIT(NULL, 0)
    6919             :         .tp_name = "irpc.drepl_takeFSMORole",
    6920             :         .tp_getset = py_drepl_takeFSMORole_getsetters,
    6921             :         .tp_methods = py_drepl_takeFSMORole_methods,
    6922             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    6923             :         .tp_new = py_drepl_takeFSMORole_new,
    6924             : };
    6925             : 
    6926           0 : static bool pack_py_drepl_takeFSMORole_args_in(PyObject *args, PyObject *kwargs, struct drepl_takeFSMORole *r)
    6927             : {
    6928             :         PyObject *py_role;
    6929           0 :         const char *kwnames[] = {
    6930             :                 "role", NULL
    6931             :         };
    6932             : 
    6933           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:drepl_takeFSMORole", discard_const_p(char *, kwnames), &py_role)) {
    6934           0 :                 return false;
    6935             :         }
    6936             : 
    6937           0 :         if (py_role == NULL) {
    6938           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.role");
    6939           0 :                 return false;
    6940             :         }
    6941             :         {
    6942           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.role));
    6943           0 :                 if (PyLong_Check(py_role)) {
    6944             :                         unsigned long long test_var;
    6945           0 :                         test_var = PyLong_AsUnsignedLongLong(py_role);
    6946           0 :                         if (PyErr_Occurred() != NULL) {
    6947           0 :                                 return false;
    6948             :                         }
    6949           0 :                         if (test_var > uint_max) {
    6950           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    6951             :                                   PyLong_Type.tp_name, uint_max, test_var);
    6952           0 :                                 return false;
    6953             :                         }
    6954           0 :                         r->in.role = test_var;
    6955             :                 } else {
    6956           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    6957             :                           PyLong_Type.tp_name);
    6958           0 :                         return false;
    6959             :                 }
    6960             :         }
    6961           0 :         return true;
    6962             : }
    6963             : 
    6964           0 : static PyObject *unpack_py_drepl_takeFSMORole_args_out(struct drepl_takeFSMORole *r)
    6965             : {
    6966             :         PyObject *result;
    6967           0 :         result = Py_None;
    6968           0 :         Py_INCREF(result);
    6969           0 :         if (!W_ERROR_IS_OK(r->out.result)) {
    6970           0 :                 PyErr_SetWERROR(r->out.result);
    6971           0 :                 return NULL;
    6972             :         }
    6973             : 
    6974           0 :         return result;
    6975             : }
    6976             : 
    6977             : 
    6978           0 : static PyObject *py_drepl_trigger_repl_secret_in_get_user_dn(PyObject *obj, void *closure)
    6979             : {
    6980           0 :         struct drepl_trigger_repl_secret *object = pytalloc_get_ptr(obj);
    6981             :         PyObject *py_user_dn;
    6982           0 :         py_user_dn = PyString_FromStringOrNULL(object->in.user_dn);
    6983           0 :         return py_user_dn;
    6984             : }
    6985             : 
    6986           0 : static int py_drepl_trigger_repl_secret_in_set_user_dn(PyObject *py_obj, PyObject *value, void *closure)
    6987             : {
    6988           0 :         struct drepl_trigger_repl_secret *object = pytalloc_get_ptr(py_obj);
    6989           0 :         if (value == NULL) {
    6990           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.user_dn");
    6991           0 :                 return -1;
    6992             :         }
    6993             :         {
    6994             :                 const char *test_str;
    6995             :                 const char *talloc_str;
    6996           0 :                 PyObject *unicode = NULL;
    6997           0 :                 if (PyUnicode_Check(value)) {
    6998           0 :                         unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    6999           0 :                         if (unicode == NULL) {
    7000           0 :                                 return -1;
    7001             :                         }
    7002           0 :                         test_str = PyBytes_AS_STRING(unicode);
    7003           0 :                 } else if (PyBytes_Check(value)) {
    7004           0 :                         test_str = PyBytes_AS_STRING(value);
    7005             :                 } else {
    7006           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    7007           0 :                         return -1;
    7008             :                 }
    7009           0 :                 talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    7010           0 :                 if (unicode != NULL) {
    7011           0 :                         Py_DECREF(unicode);
    7012             :                 }
    7013           0 :                 if (talloc_str == NULL) {
    7014           0 :                         PyErr_NoMemory();
    7015           0 :                         return -1;
    7016             :                 }
    7017           0 :                 object->in.user_dn = talloc_str;
    7018             :         }
    7019           0 :         return 0;
    7020             : }
    7021             : 
    7022             : static PyGetSetDef py_drepl_trigger_repl_secret_getsetters[] = {
    7023             :         {
    7024             :                 .name = discard_const_p(char, "in_user_dn"),
    7025             :                 .get = py_drepl_trigger_repl_secret_in_get_user_dn,
    7026             :                 .set = py_drepl_trigger_repl_secret_in_set_user_dn,
    7027             :                 .doc = discard_const_p(char, "PIDL-generated element of base type string")
    7028             :         },
    7029             :         { .name = NULL }
    7030             : };
    7031             : 
    7032           0 : static PyObject *py_drepl_trigger_repl_secret_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    7033             : {
    7034           0 :         PyObject *self = pytalloc_new(struct drepl_trigger_repl_secret, type);
    7035           0 :         return self;
    7036             : }
    7037             : 
    7038           0 : static PyObject *py_drepl_trigger_repl_secret_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
    7039             : {
    7040             : 
    7041             : 
    7042           0 :         return PyLong_FromLong(10);
    7043             : }
    7044             : 
    7045           0 : static PyObject *py_drepl_trigger_repl_secret_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
    7046             : {
    7047           0 :         const struct ndr_interface_call *call = NULL;
    7048           0 :         struct drepl_trigger_repl_secret *object = pytalloc_get_ptr(py_obj);
    7049           0 :         PyObject *ret = NULL;
    7050           0 :         struct ndr_push *push = NULL;
    7051             :         DATA_BLOB blob;
    7052             :         enum ndr_err_code err;
    7053             : 
    7054           0 :         if (ndr_table_irpc.num_calls < 11) {
    7055           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_drepl_trigger_repl_secret_ndr_pack");
    7056           0 :                 return NULL;
    7057             :         }
    7058           0 :         call = &ndr_table_irpc.calls[10];
    7059             : 
    7060           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
    7061           0 :         if (push == NULL) {
    7062           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    7063           0 :                 return NULL;
    7064             :         }
    7065             : 
    7066           0 :         push->flags |= ndr_push_flags;
    7067             : 
    7068           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
    7069           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    7070           0 :                 TALLOC_FREE(push);
    7071           0 :                 PyErr_SetNdrError(err);
    7072           0 :                 return NULL;
    7073             :         }
    7074           0 :         blob = ndr_push_blob(push);
    7075           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
    7076           0 :         TALLOC_FREE(push);
    7077           0 :         return ret;
    7078             : }
    7079             : 
    7080           0 : static PyObject *py_drepl_trigger_repl_secret_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    7081             : {
    7082           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    7083           0 :         PyObject *bigendian_obj = NULL;
    7084           0 :         PyObject *ndr64_obj = NULL;
    7085           0 :         libndr_flags ndr_push_flags = 0;
    7086             : 
    7087           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
    7088             :                 discard_const_p(char *, kwnames),
    7089             :                 &bigendian_obj,
    7090             :                 &ndr64_obj)) {
    7091           0 :                 return NULL;
    7092             :         }
    7093             : 
    7094           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    7095           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    7096             :         }
    7097           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    7098           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    7099             :         }
    7100             : 
    7101           0 :         return py_drepl_trigger_repl_secret_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
    7102             : }
    7103             : 
    7104           0 : static PyObject *py_drepl_trigger_repl_secret_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    7105             : {
    7106           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    7107           0 :         PyObject *bigendian_obj = NULL;
    7108           0 :         PyObject *ndr64_obj = NULL;
    7109           0 :         libndr_flags ndr_push_flags = 0;
    7110             : 
    7111           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
    7112             :                 discard_const_p(char *, kwnames),
    7113             :                 &bigendian_obj,
    7114             :                 &ndr64_obj)) {
    7115           0 :                 return NULL;
    7116             :         }
    7117             : 
    7118           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    7119           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    7120             :         }
    7121           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    7122           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    7123             :         }
    7124             : 
    7125           0 :         return py_drepl_trigger_repl_secret_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
    7126             : }
    7127             : 
    7128           0 : static PyObject *py_drepl_trigger_repl_secret_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
    7129             : {
    7130           0 :         const struct ndr_interface_call *call = NULL;
    7131           0 :         struct drepl_trigger_repl_secret *object = pytalloc_get_ptr(py_obj);
    7132           0 :         struct ndr_pull *pull = NULL;
    7133             :         enum ndr_err_code err;
    7134             : 
    7135           0 :         if (ndr_table_irpc.num_calls < 11) {
    7136           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_drepl_trigger_repl_secret_ndr_unpack");
    7137           0 :                 return NULL;
    7138             :         }
    7139           0 :         call = &ndr_table_irpc.calls[10];
    7140             : 
    7141           0 :         pull = ndr_pull_init_blob(blob, object);
    7142           0 :         if (pull == NULL) {
    7143           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    7144           0 :                 return NULL;
    7145             :         }
    7146             : 
    7147           0 :         pull->flags |= ndr_pull_flags;
    7148             : 
    7149           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
    7150           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    7151           0 :                 TALLOC_FREE(pull);
    7152           0 :                 PyErr_SetNdrError(err);
    7153           0 :                 return NULL;
    7154             :         }
    7155           0 :         if (!allow_remaining) {
    7156             :                 uint32_t highest_ofs;
    7157             : 
    7158           0 :                 if (pull->offset > pull->relative_highest_offset) {
    7159           0 :                         highest_ofs = pull->offset;
    7160             :                 } else {
    7161           0 :                         highest_ofs = pull->relative_highest_offset;
    7162             :                 }
    7163           0 :                 if (highest_ofs < pull->data_size) {
    7164           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
    7165             :                                 "not all bytes consumed ofs[%u] size[%u]",
    7166             :                                 highest_ofs, pull->data_size);
    7167           0 :                         TALLOC_FREE(pull);
    7168           0 :                         PyErr_SetNdrError(err);
    7169           0 :                         return NULL;
    7170             :                 }
    7171             :         }
    7172             : 
    7173           0 :         TALLOC_FREE(pull);
    7174           0 :         Py_RETURN_NONE;
    7175             : }
    7176             : 
    7177           0 : static PyObject *py_drepl_trigger_repl_secret_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    7178             : {
    7179             :         DATA_BLOB blob;
    7180           0 :         Py_ssize_t blob_length = 0;
    7181           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    7182           0 :         PyObject *bigendian_obj = NULL;
    7183           0 :         PyObject *ndr64_obj = NULL;
    7184           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    7185           0 :         PyObject *allow_remaining_obj = NULL;
    7186           0 :         bool allow_remaining = false;
    7187             : 
    7188           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
    7189             :                 discard_const_p(char *, kwnames),
    7190             :                 &blob.data, &blob_length,
    7191             :                 &bigendian_obj,
    7192             :                 &ndr64_obj,
    7193             :                 &allow_remaining_obj)) {
    7194           0 :                 return NULL;
    7195             :         }
    7196           0 :         blob.length = blob_length;
    7197             : 
    7198           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    7199           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    7200             :         }
    7201           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    7202           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    7203             :         }
    7204             : 
    7205           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    7206           0 :                 allow_remaining = true;
    7207             :         }
    7208             : 
    7209           0 :         return py_drepl_trigger_repl_secret_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
    7210             : }
    7211             : 
    7212           0 : static PyObject *py_drepl_trigger_repl_secret_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    7213             : {
    7214             :         DATA_BLOB blob;
    7215           0 :         Py_ssize_t blob_length = 0;
    7216           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    7217           0 :         PyObject *bigendian_obj = NULL;
    7218           0 :         PyObject *ndr64_obj = NULL;
    7219           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    7220           0 :         PyObject *allow_remaining_obj = NULL;
    7221           0 :         bool allow_remaining = false;
    7222             : 
    7223           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
    7224             :                 discard_const_p(char *, kwnames),
    7225             :                 &blob.data, &blob_length,
    7226             :                 &bigendian_obj,
    7227             :                 &ndr64_obj,
    7228             :                 &allow_remaining_obj)) {
    7229           0 :                 return NULL;
    7230             :         }
    7231           0 :         blob.length = blob_length;
    7232             : 
    7233           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    7234           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    7235             :         }
    7236           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    7237           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    7238             :         }
    7239             : 
    7240           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    7241           0 :                 allow_remaining = true;
    7242             :         }
    7243             : 
    7244           0 :         return py_drepl_trigger_repl_secret_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
    7245             : }
    7246             : 
    7247           0 : static PyObject *py_drepl_trigger_repl_secret_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
    7248             : {
    7249           0 :         const struct ndr_interface_call *call = NULL;
    7250           0 :         struct drepl_trigger_repl_secret *object = pytalloc_get_ptr(py_obj);
    7251             :         PyObject *ret;
    7252             :         char *retstr;
    7253             : 
    7254           0 :         if (ndr_table_irpc.num_calls < 11) {
    7255           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_drepl_trigger_repl_secret_ndr_print");
    7256           0 :                 return NULL;
    7257             :         }
    7258           0 :         call = &ndr_table_irpc.calls[10];
    7259             : 
    7260           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
    7261           0 :         ret = PyUnicode_FromString(retstr);
    7262           0 :         TALLOC_FREE(retstr);
    7263             : 
    7264           0 :         return ret;
    7265             : }
    7266             : 
    7267           0 : static PyObject *py_drepl_trigger_repl_secret_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    7268             : {
    7269           0 :         return py_drepl_trigger_repl_secret_ndr_print(py_obj, "drepl_trigger_repl_secret_in", NDR_IN);
    7270             : }
    7271             : 
    7272           0 : static PyObject *py_drepl_trigger_repl_secret_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    7273             : {
    7274           0 :         return py_drepl_trigger_repl_secret_ndr_print(py_obj, "drepl_trigger_repl_secret_out", NDR_OUT);
    7275             : }
    7276             : 
    7277             : static PyMethodDef py_drepl_trigger_repl_secret_methods[] = {
    7278             :         { "opnum", (PyCFunction)py_drepl_trigger_repl_secret_ndr_opnum, METH_NOARGS|METH_CLASS,
    7279             :                 "irpc.drepl_trigger_repl_secret.opnum() -> 10 (0x0a) " },
    7280             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_drepl_trigger_repl_secret_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
    7281             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
    7282             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_drepl_trigger_repl_secret_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
    7283             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
    7284             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_drepl_trigger_repl_secret_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
    7285             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
    7286             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_drepl_trigger_repl_secret_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
    7287             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
    7288             :         { "__ndr_print_in__", (PyCFunction)py_drepl_trigger_repl_secret_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
    7289             :         { "__ndr_print_out__", (PyCFunction)py_drepl_trigger_repl_secret_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
    7290             :         { NULL, NULL, 0, NULL }
    7291             : };
    7292             : 
    7293             : 
    7294             : static PyTypeObject drepl_trigger_repl_secret_Type = {
    7295             :         PyVarObject_HEAD_INIT(NULL, 0)
    7296             :         .tp_name = "irpc.drepl_trigger_repl_secret",
    7297             :         .tp_getset = py_drepl_trigger_repl_secret_getsetters,
    7298             :         .tp_methods = py_drepl_trigger_repl_secret_methods,
    7299             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    7300             :         .tp_new = py_drepl_trigger_repl_secret_new,
    7301             : };
    7302             : 
    7303           0 : static bool pack_py_drepl_trigger_repl_secret_args_in(PyObject *args, PyObject *kwargs, struct drepl_trigger_repl_secret *r)
    7304             : {
    7305             :         PyObject *py_user_dn;
    7306           0 :         const char *kwnames[] = {
    7307             :                 "user_dn", NULL
    7308             :         };
    7309             : 
    7310           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:drepl_trigger_repl_secret", discard_const_p(char *, kwnames), &py_user_dn)) {
    7311           0 :                 return false;
    7312             :         }
    7313             : 
    7314           0 :         if (py_user_dn == NULL) {
    7315           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.user_dn");
    7316           0 :                 return false;
    7317             :         }
    7318             :         {
    7319             :                 const char *test_str;
    7320             :                 const char *talloc_str;
    7321           0 :                 PyObject *unicode = NULL;
    7322           0 :                 if (PyUnicode_Check(py_user_dn)) {
    7323           0 :                         unicode = PyUnicode_AsEncodedString(py_user_dn, "utf-8", "ignore");
    7324           0 :                         if (unicode == NULL) {
    7325           0 :                                 return false;
    7326             :                         }
    7327           0 :                         test_str = PyBytes_AS_STRING(unicode);
    7328           0 :                 } else if (PyBytes_Check(py_user_dn)) {
    7329           0 :                         test_str = PyBytes_AS_STRING(py_user_dn);
    7330             :                 } else {
    7331           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_user_dn)->tp_name);
    7332           0 :                         return false;
    7333             :                 }
    7334           0 :                 talloc_str = talloc_strdup(r, test_str);
    7335           0 :                 if (unicode != NULL) {
    7336           0 :                         Py_DECREF(unicode);
    7337             :                 }
    7338           0 :                 if (talloc_str == NULL) {
    7339           0 :                         PyErr_NoMemory();
    7340           0 :                         return false;
    7341             :                 }
    7342           0 :                 r->in.user_dn = talloc_str;
    7343             :         }
    7344           0 :         return true;
    7345             : }
    7346             : 
    7347           0 : static PyObject *unpack_py_drepl_trigger_repl_secret_args_out(struct drepl_trigger_repl_secret *r)
    7348             : {
    7349             :         PyObject *result;
    7350           0 :         result = Py_None;
    7351           0 :         Py_INCREF(result);
    7352           0 :         return result;
    7353             : }
    7354             : 
    7355             : 
    7356           0 : static PyObject *py_dnsupdate_RODC_in_get_dom_sid(PyObject *obj, void *closure)
    7357             : {
    7358           0 :         struct dnsupdate_RODC *object = pytalloc_get_ptr(obj);
    7359             :         PyObject *py_dom_sid;
    7360           0 :         if (object->in.dom_sid == NULL) {
    7361           0 :                 Py_RETURN_NONE;
    7362             :         }
    7363           0 :         if (object->in.dom_sid == NULL) {
    7364           0 :                 py_dom_sid = Py_None;
    7365           0 :                 Py_INCREF(py_dom_sid);
    7366             :         } else {
    7367           0 :                 py_dom_sid = pytalloc_reference_ex(dom_sid_Type, object->in.dom_sid, object->in.dom_sid);
    7368             :         }
    7369           0 :         return py_dom_sid;
    7370             : }
    7371             : 
    7372           0 : static int py_dnsupdate_RODC_in_set_dom_sid(PyObject *py_obj, PyObject *value, void *closure)
    7373             : {
    7374           0 :         struct dnsupdate_RODC *object = pytalloc_get_ptr(py_obj);
    7375           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.dom_sid));
    7376           0 :         if (value == NULL) {
    7377           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.dom_sid");
    7378           0 :                 return -1;
    7379             :         }
    7380           0 :         if (value == Py_None) {
    7381           0 :                 object->in.dom_sid = NULL;
    7382             :         } else {
    7383           0 :                 object->in.dom_sid = NULL;
    7384           0 :                 PY_CHECK_TYPE(dom_sid_Type, value, return -1;);
    7385           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    7386           0 :                         PyErr_NoMemory();
    7387           0 :                         return -1;
    7388             :                 }
    7389           0 :                 object->in.dom_sid = (struct dom_sid *)pytalloc_get_ptr(value);
    7390             :         }
    7391           0 :         return 0;
    7392             : }
    7393             : 
    7394           0 : static PyObject *py_dnsupdate_RODC_in_get_site_name(PyObject *obj, void *closure)
    7395             : {
    7396           0 :         struct dnsupdate_RODC *object = pytalloc_get_ptr(obj);
    7397             :         PyObject *py_site_name;
    7398           0 :         if (object->in.site_name == NULL) {
    7399           0 :                 Py_RETURN_NONE;
    7400             :         }
    7401           0 :         if (object->in.site_name == NULL) {
    7402           0 :                 py_site_name = Py_None;
    7403           0 :                 Py_INCREF(py_site_name);
    7404             :         } else {
    7405           0 :                 if (object->in.site_name == NULL) {
    7406           0 :                         py_site_name = Py_None;
    7407           0 :                         Py_INCREF(py_site_name);
    7408             :                 } else {
    7409           0 :                         py_site_name = PyUnicode_Decode(object->in.site_name, strlen(object->in.site_name), "utf-8", "ignore");
    7410             :                 }
    7411             :         }
    7412           0 :         return py_site_name;
    7413             : }
    7414             : 
    7415           0 : static int py_dnsupdate_RODC_in_set_site_name(PyObject *py_obj, PyObject *value, void *closure)
    7416             : {
    7417           0 :         struct dnsupdate_RODC *object = pytalloc_get_ptr(py_obj);
    7418           0 :         if (value == NULL) {
    7419           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.site_name");
    7420           0 :                 return -1;
    7421             :         }
    7422           0 :         if (value == Py_None) {
    7423           0 :                 object->in.site_name = NULL;
    7424             :         } else {
    7425           0 :                 object->in.site_name = NULL;
    7426             :                 {
    7427             :                         const char *test_str;
    7428             :                         const char *talloc_str;
    7429           0 :                         PyObject *unicode = NULL;
    7430           0 :                         if (PyUnicode_Check(value)) {
    7431           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    7432           0 :                                 if (unicode == NULL) {
    7433           0 :                                         return -1;
    7434             :                                 }
    7435           0 :                                 test_str = PyBytes_AS_STRING(unicode);
    7436           0 :                         } else if (PyBytes_Check(value)) {
    7437           0 :                                 test_str = PyBytes_AS_STRING(value);
    7438             :                         } else {
    7439           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    7440           0 :                                 return -1;
    7441             :                         }
    7442           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    7443           0 :                         if (unicode != NULL) {
    7444           0 :                                 Py_DECREF(unicode);
    7445             :                         }
    7446           0 :                         if (talloc_str == NULL) {
    7447           0 :                                 PyErr_NoMemory();
    7448           0 :                                 return -1;
    7449             :                         }
    7450           0 :                         object->in.site_name = talloc_str;
    7451             :                 }
    7452             :         }
    7453           0 :         return 0;
    7454             : }
    7455             : 
    7456           0 : static PyObject *py_dnsupdate_RODC_in_get_dns_ttl(PyObject *obj, void *closure)
    7457             : {
    7458           0 :         struct dnsupdate_RODC *object = pytalloc_get_ptr(obj);
    7459             :         PyObject *py_dns_ttl;
    7460           0 :         py_dns_ttl = PyLong_FromUnsignedLongLong((uint32_t)(object->in.dns_ttl));
    7461           0 :         return py_dns_ttl;
    7462             : }
    7463             : 
    7464           0 : static int py_dnsupdate_RODC_in_set_dns_ttl(PyObject *py_obj, PyObject *value, void *closure)
    7465             : {
    7466           0 :         struct dnsupdate_RODC *object = pytalloc_get_ptr(py_obj);
    7467           0 :         if (value == NULL) {
    7468           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.dns_ttl");
    7469           0 :                 return -1;
    7470             :         }
    7471             :         {
    7472           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.dns_ttl));
    7473           0 :                 if (PyLong_Check(value)) {
    7474             :                         unsigned long long test_var;
    7475           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7476           0 :                         if (PyErr_Occurred() != NULL) {
    7477           0 :                                 return -1;
    7478             :                         }
    7479           0 :                         if (test_var > uint_max) {
    7480           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7481             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7482           0 :                                 return -1;
    7483             :                         }
    7484           0 :                         object->in.dns_ttl = test_var;
    7485             :                 } else {
    7486           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7487             :                           PyLong_Type.tp_name);
    7488           0 :                         return -1;
    7489             :                 }
    7490             :         }
    7491           0 :         return 0;
    7492             : }
    7493             : 
    7494           0 : static PyObject *py_dnsupdate_RODC_in_get_dns_names(PyObject *obj, void *closure)
    7495             : {
    7496           0 :         struct dnsupdate_RODC *object = pytalloc_get_ptr(obj);
    7497             :         PyObject *py_dns_names;
    7498           0 :         if (object->in.dns_names == NULL) {
    7499           0 :                 Py_RETURN_NONE;
    7500             :         }
    7501           0 :         py_dns_names = pytalloc_reference_ex(NL_DNS_NAME_INFO_ARRAY_Type, object->in.dns_names, object->in.dns_names);
    7502           0 :         return py_dns_names;
    7503             : }
    7504             : 
    7505           0 : static int py_dnsupdate_RODC_in_set_dns_names(PyObject *py_obj, PyObject *value, void *closure)
    7506             : {
    7507           0 :         struct dnsupdate_RODC *object = pytalloc_get_ptr(py_obj);
    7508           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.dns_names));
    7509           0 :         if (value == NULL) {
    7510           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.dns_names");
    7511           0 :                 return -1;
    7512             :         }
    7513           0 :         object->in.dns_names = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.dns_names);
    7514           0 :         if (object->in.dns_names == NULL) {
    7515           0 :                 PyErr_NoMemory();
    7516           0 :                 return -1;
    7517             :         }
    7518           0 :         PY_CHECK_TYPE(NL_DNS_NAME_INFO_ARRAY_Type, value, return -1;);
    7519           0 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    7520           0 :                 PyErr_NoMemory();
    7521           0 :                 return -1;
    7522             :         }
    7523           0 :         object->in.dns_names = (struct NL_DNS_NAME_INFO_ARRAY *)pytalloc_get_ptr(value);
    7524           0 :         return 0;
    7525             : }
    7526             : 
    7527           0 : static PyObject *py_dnsupdate_RODC_out_get_dns_names(PyObject *obj, void *closure)
    7528             : {
    7529           0 :         struct dnsupdate_RODC *object = pytalloc_get_ptr(obj);
    7530             :         PyObject *py_dns_names;
    7531           0 :         if (object->out.dns_names == NULL) {
    7532           0 :                 Py_RETURN_NONE;
    7533             :         }
    7534           0 :         py_dns_names = pytalloc_reference_ex(NL_DNS_NAME_INFO_ARRAY_Type, object->out.dns_names, object->out.dns_names);
    7535           0 :         return py_dns_names;
    7536             : }
    7537             : 
    7538           0 : static int py_dnsupdate_RODC_out_set_dns_names(PyObject *py_obj, PyObject *value, void *closure)
    7539             : {
    7540           0 :         struct dnsupdate_RODC *object = pytalloc_get_ptr(py_obj);
    7541           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.dns_names));
    7542           0 :         if (value == NULL) {
    7543           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.dns_names");
    7544           0 :                 return -1;
    7545             :         }
    7546           0 :         object->out.dns_names = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.dns_names);
    7547           0 :         if (object->out.dns_names == NULL) {
    7548           0 :                 PyErr_NoMemory();
    7549           0 :                 return -1;
    7550             :         }
    7551           0 :         PY_CHECK_TYPE(NL_DNS_NAME_INFO_ARRAY_Type, value, return -1;);
    7552           0 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    7553           0 :                 PyErr_NoMemory();
    7554           0 :                 return -1;
    7555             :         }
    7556           0 :         object->out.dns_names = (struct NL_DNS_NAME_INFO_ARRAY *)pytalloc_get_ptr(value);
    7557           0 :         return 0;
    7558             : }
    7559             : 
    7560           0 : static PyObject *py_dnsupdate_RODC_get_result(PyObject *obj, void *closure)
    7561             : {
    7562           0 :         struct dnsupdate_RODC *object = pytalloc_get_ptr(obj);
    7563             :         PyObject *py_result;
    7564           0 :         py_result = PyErr_FromNTSTATUS(object->out.result);
    7565           0 :         return py_result;
    7566             : }
    7567             : 
    7568           0 : static int py_dnsupdate_RODC_set_result(PyObject *py_obj, PyObject *value, void *closure)
    7569             : {
    7570           0 :         struct dnsupdate_RODC *object = pytalloc_get_ptr(py_obj);
    7571           0 :         if (value == NULL) {
    7572           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.result");
    7573           0 :                 return -1;
    7574             :         }
    7575           0 :         object->out.result = NT_STATUS(PyLong_AsLong(value));
    7576           0 :         return 0;
    7577             : }
    7578             : 
    7579             : static PyGetSetDef py_dnsupdate_RODC_getsetters[] = {
    7580             :         {
    7581             :                 .name = discard_const_p(char, "in_dom_sid"),
    7582             :                 .get = py_dnsupdate_RODC_in_get_dom_sid,
    7583             :                 .set = py_dnsupdate_RODC_in_set_dom_sid,
    7584             :                 .doc = discard_const_p(char, "PIDL-generated element of base type dom_sid")
    7585             :         },
    7586             :         {
    7587             :                 .name = discard_const_p(char, "in_site_name"),
    7588             :                 .get = py_dnsupdate_RODC_in_get_site_name,
    7589             :                 .set = py_dnsupdate_RODC_in_set_site_name,
    7590             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
    7591             :         },
    7592             :         {
    7593             :                 .name = discard_const_p(char, "in_dns_ttl"),
    7594             :                 .get = py_dnsupdate_RODC_in_get_dns_ttl,
    7595             :                 .set = py_dnsupdate_RODC_in_set_dns_ttl,
    7596             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    7597             :         },
    7598             :         {
    7599             :                 .name = discard_const_p(char, "in_dns_names"),
    7600             :                 .get = py_dnsupdate_RODC_in_get_dns_names,
    7601             :                 .set = py_dnsupdate_RODC_in_set_dns_names,
    7602             :                 .doc = discard_const_p(char, "PIDL-generated element of base type NL_DNS_NAME_INFO_ARRAY")
    7603             :         },
    7604             :         {
    7605             :                 .name = discard_const_p(char, "out_dns_names"),
    7606             :                 .get = py_dnsupdate_RODC_out_get_dns_names,
    7607             :                 .set = py_dnsupdate_RODC_out_set_dns_names,
    7608             :                 .doc = discard_const_p(char, "PIDL-generated element of base type NL_DNS_NAME_INFO_ARRAY")
    7609             :         },
    7610             :         {
    7611             :                 .name = discard_const_p(char, "result"),
    7612             :                 .get = py_dnsupdate_RODC_get_result,
    7613             :                 .set = py_dnsupdate_RODC_set_result,
    7614             :                 .doc = discard_const_p(char, "PIDL-generated element of type NTSTATUS")
    7615             :         },
    7616             :         { .name = NULL }
    7617             : };
    7618             : 
    7619           0 : static PyObject *py_dnsupdate_RODC_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    7620             : {
    7621           0 :         PyObject *self = pytalloc_new(struct dnsupdate_RODC, type);
    7622           0 :         struct dnsupdate_RODC *_self = (struct dnsupdate_RODC *)pytalloc_get_ptr(self);
    7623           0 :         TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
    7624           0 :         _self->in.dns_names = talloc_zero(mem_ctx, struct NL_DNS_NAME_INFO_ARRAY);
    7625           0 :         _self->out.dns_names = talloc_zero(mem_ctx, struct NL_DNS_NAME_INFO_ARRAY);
    7626           0 :         return self;
    7627             : }
    7628             : 
    7629           0 : static PyObject *py_dnsupdate_RODC_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
    7630             : {
    7631             : 
    7632             : 
    7633           0 :         return PyLong_FromLong(11);
    7634             : }
    7635             : 
    7636           0 : static PyObject *py_dnsupdate_RODC_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
    7637             : {
    7638           0 :         const struct ndr_interface_call *call = NULL;
    7639           0 :         struct dnsupdate_RODC *object = pytalloc_get_ptr(py_obj);
    7640           0 :         PyObject *ret = NULL;
    7641           0 :         struct ndr_push *push = NULL;
    7642             :         DATA_BLOB blob;
    7643             :         enum ndr_err_code err;
    7644             : 
    7645           0 :         if (ndr_table_irpc.num_calls < 12) {
    7646           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_dnsupdate_RODC_ndr_pack");
    7647           0 :                 return NULL;
    7648             :         }
    7649           0 :         call = &ndr_table_irpc.calls[11];
    7650             : 
    7651           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
    7652           0 :         if (push == NULL) {
    7653           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    7654           0 :                 return NULL;
    7655             :         }
    7656             : 
    7657           0 :         push->flags |= ndr_push_flags;
    7658             : 
    7659           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
    7660           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    7661           0 :                 TALLOC_FREE(push);
    7662           0 :                 PyErr_SetNdrError(err);
    7663           0 :                 return NULL;
    7664             :         }
    7665           0 :         blob = ndr_push_blob(push);
    7666           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
    7667           0 :         TALLOC_FREE(push);
    7668           0 :         return ret;
    7669             : }
    7670             : 
    7671           0 : static PyObject *py_dnsupdate_RODC_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    7672             : {
    7673           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    7674           0 :         PyObject *bigendian_obj = NULL;
    7675           0 :         PyObject *ndr64_obj = NULL;
    7676           0 :         libndr_flags ndr_push_flags = 0;
    7677             : 
    7678           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
    7679             :                 discard_const_p(char *, kwnames),
    7680             :                 &bigendian_obj,
    7681             :                 &ndr64_obj)) {
    7682           0 :                 return NULL;
    7683             :         }
    7684             : 
    7685           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    7686           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    7687             :         }
    7688           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    7689           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    7690             :         }
    7691             : 
    7692           0 :         return py_dnsupdate_RODC_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
    7693             : }
    7694             : 
    7695           0 : static PyObject *py_dnsupdate_RODC_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    7696             : {
    7697           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    7698           0 :         PyObject *bigendian_obj = NULL;
    7699           0 :         PyObject *ndr64_obj = NULL;
    7700           0 :         libndr_flags ndr_push_flags = 0;
    7701             : 
    7702           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
    7703             :                 discard_const_p(char *, kwnames),
    7704             :                 &bigendian_obj,
    7705             :                 &ndr64_obj)) {
    7706           0 :                 return NULL;
    7707             :         }
    7708             : 
    7709           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    7710           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    7711             :         }
    7712           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    7713           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    7714             :         }
    7715             : 
    7716           0 :         return py_dnsupdate_RODC_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
    7717             : }
    7718             : 
    7719           0 : static PyObject *py_dnsupdate_RODC_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
    7720             : {
    7721           0 :         const struct ndr_interface_call *call = NULL;
    7722           0 :         struct dnsupdate_RODC *object = pytalloc_get_ptr(py_obj);
    7723           0 :         struct ndr_pull *pull = NULL;
    7724             :         enum ndr_err_code err;
    7725             : 
    7726           0 :         if (ndr_table_irpc.num_calls < 12) {
    7727           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_dnsupdate_RODC_ndr_unpack");
    7728           0 :                 return NULL;
    7729             :         }
    7730           0 :         call = &ndr_table_irpc.calls[11];
    7731             : 
    7732           0 :         pull = ndr_pull_init_blob(blob, object);
    7733           0 :         if (pull == NULL) {
    7734           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    7735           0 :                 return NULL;
    7736             :         }
    7737             : 
    7738           0 :         pull->flags |= ndr_pull_flags;
    7739             : 
    7740           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
    7741           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    7742           0 :                 TALLOC_FREE(pull);
    7743           0 :                 PyErr_SetNdrError(err);
    7744           0 :                 return NULL;
    7745             :         }
    7746           0 :         if (!allow_remaining) {
    7747             :                 uint32_t highest_ofs;
    7748             : 
    7749           0 :                 if (pull->offset > pull->relative_highest_offset) {
    7750           0 :                         highest_ofs = pull->offset;
    7751             :                 } else {
    7752           0 :                         highest_ofs = pull->relative_highest_offset;
    7753             :                 }
    7754           0 :                 if (highest_ofs < pull->data_size) {
    7755           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
    7756             :                                 "not all bytes consumed ofs[%u] size[%u]",
    7757             :                                 highest_ofs, pull->data_size);
    7758           0 :                         TALLOC_FREE(pull);
    7759           0 :                         PyErr_SetNdrError(err);
    7760           0 :                         return NULL;
    7761             :                 }
    7762             :         }
    7763             : 
    7764           0 :         TALLOC_FREE(pull);
    7765           0 :         Py_RETURN_NONE;
    7766             : }
    7767             : 
    7768           0 : static PyObject *py_dnsupdate_RODC_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    7769             : {
    7770             :         DATA_BLOB blob;
    7771           0 :         Py_ssize_t blob_length = 0;
    7772           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    7773           0 :         PyObject *bigendian_obj = NULL;
    7774           0 :         PyObject *ndr64_obj = NULL;
    7775           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    7776           0 :         PyObject *allow_remaining_obj = NULL;
    7777           0 :         bool allow_remaining = false;
    7778             : 
    7779           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
    7780             :                 discard_const_p(char *, kwnames),
    7781             :                 &blob.data, &blob_length,
    7782             :                 &bigendian_obj,
    7783             :                 &ndr64_obj,
    7784             :                 &allow_remaining_obj)) {
    7785           0 :                 return NULL;
    7786             :         }
    7787           0 :         blob.length = blob_length;
    7788             : 
    7789           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    7790           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    7791             :         }
    7792           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    7793           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    7794             :         }
    7795             : 
    7796           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    7797           0 :                 allow_remaining = true;
    7798             :         }
    7799             : 
    7800           0 :         return py_dnsupdate_RODC_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
    7801             : }
    7802             : 
    7803           0 : static PyObject *py_dnsupdate_RODC_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    7804             : {
    7805             :         DATA_BLOB blob;
    7806           0 :         Py_ssize_t blob_length = 0;
    7807           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    7808           0 :         PyObject *bigendian_obj = NULL;
    7809           0 :         PyObject *ndr64_obj = NULL;
    7810           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    7811           0 :         PyObject *allow_remaining_obj = NULL;
    7812           0 :         bool allow_remaining = false;
    7813             : 
    7814           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
    7815             :                 discard_const_p(char *, kwnames),
    7816             :                 &blob.data, &blob_length,
    7817             :                 &bigendian_obj,
    7818             :                 &ndr64_obj,
    7819             :                 &allow_remaining_obj)) {
    7820           0 :                 return NULL;
    7821             :         }
    7822           0 :         blob.length = blob_length;
    7823             : 
    7824           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    7825           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    7826             :         }
    7827           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    7828           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    7829             :         }
    7830             : 
    7831           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    7832           0 :                 allow_remaining = true;
    7833             :         }
    7834             : 
    7835           0 :         return py_dnsupdate_RODC_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
    7836             : }
    7837             : 
    7838           0 : static PyObject *py_dnsupdate_RODC_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
    7839             : {
    7840           0 :         const struct ndr_interface_call *call = NULL;
    7841           0 :         struct dnsupdate_RODC *object = pytalloc_get_ptr(py_obj);
    7842             :         PyObject *ret;
    7843             :         char *retstr;
    7844             : 
    7845           0 :         if (ndr_table_irpc.num_calls < 12) {
    7846           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_dnsupdate_RODC_ndr_print");
    7847           0 :                 return NULL;
    7848             :         }
    7849           0 :         call = &ndr_table_irpc.calls[11];
    7850             : 
    7851           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
    7852           0 :         ret = PyUnicode_FromString(retstr);
    7853           0 :         TALLOC_FREE(retstr);
    7854             : 
    7855           0 :         return ret;
    7856             : }
    7857             : 
    7858           0 : static PyObject *py_dnsupdate_RODC_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    7859             : {
    7860           0 :         return py_dnsupdate_RODC_ndr_print(py_obj, "dnsupdate_RODC_in", NDR_IN);
    7861             : }
    7862             : 
    7863           0 : static PyObject *py_dnsupdate_RODC_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    7864             : {
    7865           0 :         return py_dnsupdate_RODC_ndr_print(py_obj, "dnsupdate_RODC_out", NDR_OUT);
    7866             : }
    7867             : 
    7868             : static PyMethodDef py_dnsupdate_RODC_methods[] = {
    7869             :         { "opnum", (PyCFunction)py_dnsupdate_RODC_ndr_opnum, METH_NOARGS|METH_CLASS,
    7870             :                 "irpc.dnsupdate_RODC.opnum() -> 11 (0x0b) " },
    7871             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_dnsupdate_RODC_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
    7872             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
    7873             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_dnsupdate_RODC_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
    7874             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
    7875             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_dnsupdate_RODC_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
    7876             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
    7877             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_dnsupdate_RODC_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
    7878             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
    7879             :         { "__ndr_print_in__", (PyCFunction)py_dnsupdate_RODC_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
    7880             :         { "__ndr_print_out__", (PyCFunction)py_dnsupdate_RODC_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
    7881             :         { NULL, NULL, 0, NULL }
    7882             : };
    7883             : 
    7884             : 
    7885             : static PyTypeObject dnsupdate_RODC_Type = {
    7886             :         PyVarObject_HEAD_INIT(NULL, 0)
    7887             :         .tp_name = "irpc.dnsupdate_RODC",
    7888             :         .tp_getset = py_dnsupdate_RODC_getsetters,
    7889             :         .tp_methods = py_dnsupdate_RODC_methods,
    7890             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    7891             :         .tp_new = py_dnsupdate_RODC_new,
    7892             : };
    7893             : 
    7894           0 : static bool pack_py_dnsupdate_RODC_args_in(PyObject *args, PyObject *kwargs, struct dnsupdate_RODC *r)
    7895             : {
    7896             :         PyObject *py_dom_sid;
    7897             :         PyObject *py_site_name;
    7898             :         PyObject *py_dns_ttl;
    7899             :         PyObject *py_dns_names;
    7900           0 :         const char *kwnames[] = {
    7901             :                 "dom_sid", "site_name", "dns_ttl", "dns_names", NULL
    7902             :         };
    7903             : 
    7904           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:dnsupdate_RODC", discard_const_p(char *, kwnames), &py_dom_sid, &py_site_name, &py_dns_ttl, &py_dns_names)) {
    7905           0 :                 return false;
    7906             :         }
    7907             : 
    7908           0 :         if (py_dom_sid == NULL) {
    7909           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.dom_sid");
    7910           0 :                 return false;
    7911             :         }
    7912           0 :         if (py_dom_sid == Py_None) {
    7913           0 :                 r->in.dom_sid = NULL;
    7914             :         } else {
    7915           0 :                 r->in.dom_sid = NULL;
    7916           0 :                 PY_CHECK_TYPE(dom_sid_Type, py_dom_sid, return false;);
    7917           0 :                 if (talloc_reference(r, pytalloc_get_mem_ctx(py_dom_sid)) == NULL) {
    7918           0 :                         PyErr_NoMemory();
    7919           0 :                         return false;
    7920             :                 }
    7921           0 :                 r->in.dom_sid = (struct dom_sid *)pytalloc_get_ptr(py_dom_sid);
    7922             :         }
    7923           0 :         if (py_site_name == NULL) {
    7924           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.site_name");
    7925           0 :                 return false;
    7926             :         }
    7927           0 :         if (py_site_name == Py_None) {
    7928           0 :                 r->in.site_name = NULL;
    7929             :         } else {
    7930           0 :                 r->in.site_name = NULL;
    7931             :                 {
    7932             :                         const char *test_str;
    7933             :                         const char *talloc_str;
    7934           0 :                         PyObject *unicode = NULL;
    7935           0 :                         if (PyUnicode_Check(py_site_name)) {
    7936           0 :                                 unicode = PyUnicode_AsEncodedString(py_site_name, "utf-8", "ignore");
    7937           0 :                                 if (unicode == NULL) {
    7938           0 :                                         return false;
    7939             :                                 }
    7940           0 :                                 test_str = PyBytes_AS_STRING(unicode);
    7941           0 :                         } else if (PyBytes_Check(py_site_name)) {
    7942           0 :                                 test_str = PyBytes_AS_STRING(py_site_name);
    7943             :                         } else {
    7944           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_site_name)->tp_name);
    7945           0 :                                 return false;
    7946             :                         }
    7947           0 :                         talloc_str = talloc_strdup(r, test_str);
    7948           0 :                         if (unicode != NULL) {
    7949           0 :                                 Py_DECREF(unicode);
    7950             :                         }
    7951           0 :                         if (talloc_str == NULL) {
    7952           0 :                                 PyErr_NoMemory();
    7953           0 :                                 return false;
    7954             :                         }
    7955           0 :                         r->in.site_name = talloc_str;
    7956             :                 }
    7957             :         }
    7958           0 :         if (py_dns_ttl == NULL) {
    7959           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.dns_ttl");
    7960           0 :                 return false;
    7961             :         }
    7962             :         {
    7963           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.dns_ttl));
    7964           0 :                 if (PyLong_Check(py_dns_ttl)) {
    7965             :                         unsigned long long test_var;
    7966           0 :                         test_var = PyLong_AsUnsignedLongLong(py_dns_ttl);
    7967           0 :                         if (PyErr_Occurred() != NULL) {
    7968           0 :                                 return false;
    7969             :                         }
    7970           0 :                         if (test_var > uint_max) {
    7971           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7972             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7973           0 :                                 return false;
    7974             :                         }
    7975           0 :                         r->in.dns_ttl = test_var;
    7976             :                 } else {
    7977           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7978             :                           PyLong_Type.tp_name);
    7979           0 :                         return false;
    7980             :                 }
    7981             :         }
    7982           0 :         if (py_dns_names == NULL) {
    7983           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.dns_names");
    7984           0 :                 return false;
    7985             :         }
    7986           0 :         r->in.dns_names = talloc_ptrtype(r, r->in.dns_names);
    7987           0 :         if (r->in.dns_names == NULL) {
    7988           0 :                 PyErr_NoMemory();
    7989           0 :                 return false;
    7990             :         }
    7991           0 :         PY_CHECK_TYPE(NL_DNS_NAME_INFO_ARRAY_Type, py_dns_names, return false;);
    7992           0 :         if (talloc_reference(r, pytalloc_get_mem_ctx(py_dns_names)) == NULL) {
    7993           0 :                 PyErr_NoMemory();
    7994           0 :                 return false;
    7995             :         }
    7996           0 :         r->in.dns_names = (struct NL_DNS_NAME_INFO_ARRAY *)pytalloc_get_ptr(py_dns_names);
    7997           0 :         return true;
    7998             : }
    7999             : 
    8000           0 : static PyObject *unpack_py_dnsupdate_RODC_args_out(struct dnsupdate_RODC *r)
    8001             : {
    8002             :         PyObject *result;
    8003             :         PyObject *py_dns_names;
    8004           0 :         py_dns_names = pytalloc_reference_ex(NL_DNS_NAME_INFO_ARRAY_Type, r->out.dns_names, r->out.dns_names);
    8005           0 :         result = py_dns_names;
    8006           0 :         if (NT_STATUS_IS_ERR(r->out.result)) {
    8007           0 :                 PyErr_SetNTSTATUS(r->out.result);
    8008           0 :                 return NULL;
    8009             :         }
    8010             : 
    8011           0 :         return result;
    8012             : }
    8013             : 
    8014             : 
    8015           0 : static PyObject *py_dnssrv_reload_dns_zones_get_result(PyObject *obj, void *closure)
    8016             : {
    8017           0 :         struct dnssrv_reload_dns_zones *object = pytalloc_get_ptr(obj);
    8018             :         PyObject *py_result;
    8019           0 :         py_result = PyErr_FromNTSTATUS(object->out.result);
    8020           0 :         return py_result;
    8021             : }
    8022             : 
    8023           0 : static int py_dnssrv_reload_dns_zones_set_result(PyObject *py_obj, PyObject *value, void *closure)
    8024             : {
    8025           0 :         struct dnssrv_reload_dns_zones *object = pytalloc_get_ptr(py_obj);
    8026           0 :         if (value == NULL) {
    8027           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.result");
    8028           0 :                 return -1;
    8029             :         }
    8030           0 :         object->out.result = NT_STATUS(PyLong_AsLong(value));
    8031           0 :         return 0;
    8032             : }
    8033             : 
    8034             : static PyGetSetDef py_dnssrv_reload_dns_zones_getsetters[] = {
    8035             :         {
    8036             :                 .name = discard_const_p(char, "result"),
    8037             :                 .get = py_dnssrv_reload_dns_zones_get_result,
    8038             :                 .set = py_dnssrv_reload_dns_zones_set_result,
    8039             :                 .doc = discard_const_p(char, "PIDL-generated element of type NTSTATUS")
    8040             :         },
    8041             :         { .name = NULL }
    8042             : };
    8043             : 
    8044           0 : static PyObject *py_dnssrv_reload_dns_zones_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    8045             : {
    8046           0 :         PyObject *self = pytalloc_new(struct dnssrv_reload_dns_zones, type);
    8047           0 :         return self;
    8048             : }
    8049             : 
    8050           0 : static PyObject *py_dnssrv_reload_dns_zones_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
    8051             : {
    8052             : 
    8053             : 
    8054           0 :         return PyLong_FromLong(12);
    8055             : }
    8056             : 
    8057           0 : static PyObject *py_dnssrv_reload_dns_zones_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
    8058             : {
    8059           0 :         const struct ndr_interface_call *call = NULL;
    8060           0 :         struct dnssrv_reload_dns_zones *object = pytalloc_get_ptr(py_obj);
    8061           0 :         PyObject *ret = NULL;
    8062           0 :         struct ndr_push *push = NULL;
    8063             :         DATA_BLOB blob;
    8064             :         enum ndr_err_code err;
    8065             : 
    8066           0 :         if (ndr_table_irpc.num_calls < 13) {
    8067           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_dnssrv_reload_dns_zones_ndr_pack");
    8068           0 :                 return NULL;
    8069             :         }
    8070           0 :         call = &ndr_table_irpc.calls[12];
    8071             : 
    8072           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
    8073           0 :         if (push == NULL) {
    8074           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    8075           0 :                 return NULL;
    8076             :         }
    8077             : 
    8078           0 :         push->flags |= ndr_push_flags;
    8079             : 
    8080           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
    8081           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    8082           0 :                 TALLOC_FREE(push);
    8083           0 :                 PyErr_SetNdrError(err);
    8084           0 :                 return NULL;
    8085             :         }
    8086           0 :         blob = ndr_push_blob(push);
    8087           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
    8088           0 :         TALLOC_FREE(push);
    8089           0 :         return ret;
    8090             : }
    8091             : 
    8092           0 : static PyObject *py_dnssrv_reload_dns_zones_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    8093             : {
    8094           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    8095           0 :         PyObject *bigendian_obj = NULL;
    8096           0 :         PyObject *ndr64_obj = NULL;
    8097           0 :         libndr_flags ndr_push_flags = 0;
    8098             : 
    8099           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
    8100             :                 discard_const_p(char *, kwnames),
    8101             :                 &bigendian_obj,
    8102             :                 &ndr64_obj)) {
    8103           0 :                 return NULL;
    8104             :         }
    8105             : 
    8106           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    8107           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    8108             :         }
    8109           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    8110           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    8111             :         }
    8112             : 
    8113           0 :         return py_dnssrv_reload_dns_zones_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
    8114             : }
    8115             : 
    8116           0 : static PyObject *py_dnssrv_reload_dns_zones_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    8117             : {
    8118           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
    8119           0 :         PyObject *bigendian_obj = NULL;
    8120           0 :         PyObject *ndr64_obj = NULL;
    8121           0 :         libndr_flags ndr_push_flags = 0;
    8122             : 
    8123           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
    8124             :                 discard_const_p(char *, kwnames),
    8125             :                 &bigendian_obj,
    8126             :                 &ndr64_obj)) {
    8127           0 :                 return NULL;
    8128             :         }
    8129             : 
    8130           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    8131           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
    8132             :         }
    8133           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    8134           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
    8135             :         }
    8136             : 
    8137           0 :         return py_dnssrv_reload_dns_zones_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
    8138             : }
    8139             : 
    8140           0 : static PyObject *py_dnssrv_reload_dns_zones_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
    8141             : {
    8142           0 :         const struct ndr_interface_call *call = NULL;
    8143           0 :         struct dnssrv_reload_dns_zones *object = pytalloc_get_ptr(py_obj);
    8144           0 :         struct ndr_pull *pull = NULL;
    8145             :         enum ndr_err_code err;
    8146             : 
    8147           0 :         if (ndr_table_irpc.num_calls < 13) {
    8148           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_dnssrv_reload_dns_zones_ndr_unpack");
    8149           0 :                 return NULL;
    8150             :         }
    8151           0 :         call = &ndr_table_irpc.calls[12];
    8152             : 
    8153           0 :         pull = ndr_pull_init_blob(blob, object);
    8154           0 :         if (pull == NULL) {
    8155           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    8156           0 :                 return NULL;
    8157             :         }
    8158             : 
    8159           0 :         pull->flags |= ndr_pull_flags;
    8160             : 
    8161           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
    8162           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    8163           0 :                 TALLOC_FREE(pull);
    8164           0 :                 PyErr_SetNdrError(err);
    8165           0 :                 return NULL;
    8166             :         }
    8167           0 :         if (!allow_remaining) {
    8168             :                 uint32_t highest_ofs;
    8169             : 
    8170           0 :                 if (pull->offset > pull->relative_highest_offset) {
    8171           0 :                         highest_ofs = pull->offset;
    8172             :                 } else {
    8173           0 :                         highest_ofs = pull->relative_highest_offset;
    8174             :                 }
    8175           0 :                 if (highest_ofs < pull->data_size) {
    8176           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
    8177             :                                 "not all bytes consumed ofs[%u] size[%u]",
    8178             :                                 highest_ofs, pull->data_size);
    8179           0 :                         TALLOC_FREE(pull);
    8180           0 :                         PyErr_SetNdrError(err);
    8181           0 :                         return NULL;
    8182             :                 }
    8183             :         }
    8184             : 
    8185           0 :         TALLOC_FREE(pull);
    8186           0 :         Py_RETURN_NONE;
    8187             : }
    8188             : 
    8189           0 : static PyObject *py_dnssrv_reload_dns_zones_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    8190             : {
    8191             :         DATA_BLOB blob;
    8192           0 :         Py_ssize_t blob_length = 0;
    8193           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    8194           0 :         PyObject *bigendian_obj = NULL;
    8195           0 :         PyObject *ndr64_obj = NULL;
    8196           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    8197           0 :         PyObject *allow_remaining_obj = NULL;
    8198           0 :         bool allow_remaining = false;
    8199             : 
    8200           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
    8201             :                 discard_const_p(char *, kwnames),
    8202             :                 &blob.data, &blob_length,
    8203             :                 &bigendian_obj,
    8204             :                 &ndr64_obj,
    8205             :                 &allow_remaining_obj)) {
    8206           0 :                 return NULL;
    8207             :         }
    8208           0 :         blob.length = blob_length;
    8209             : 
    8210           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    8211           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    8212             :         }
    8213           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    8214           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    8215             :         }
    8216             : 
    8217           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    8218           0 :                 allow_remaining = true;
    8219             :         }
    8220             : 
    8221           0 :         return py_dnssrv_reload_dns_zones_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
    8222             : }
    8223             : 
    8224           0 : static PyObject *py_dnssrv_reload_dns_zones_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    8225             : {
    8226             :         DATA_BLOB blob;
    8227           0 :         Py_ssize_t blob_length = 0;
    8228           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
    8229           0 :         PyObject *bigendian_obj = NULL;
    8230           0 :         PyObject *ndr64_obj = NULL;
    8231           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
    8232           0 :         PyObject *allow_remaining_obj = NULL;
    8233           0 :         bool allow_remaining = false;
    8234             : 
    8235           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
    8236             :                 discard_const_p(char *, kwnames),
    8237             :                 &blob.data, &blob_length,
    8238             :                 &bigendian_obj,
    8239             :                 &ndr64_obj,
    8240             :                 &allow_remaining_obj)) {
    8241           0 :                 return NULL;
    8242             :         }
    8243           0 :         blob.length = blob_length;
    8244             : 
    8245           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
    8246           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
    8247             :         }
    8248           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
    8249           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
    8250             :         }
    8251             : 
    8252           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    8253           0 :                 allow_remaining = true;
    8254             :         }
    8255             : 
    8256           0 :         return py_dnssrv_reload_dns_zones_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
    8257             : }
    8258             : 
    8259           0 : static PyObject *py_dnssrv_reload_dns_zones_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
    8260             : {
    8261           0 :         const struct ndr_interface_call *call = NULL;
    8262           0 :         struct dnssrv_reload_dns_zones *object = pytalloc_get_ptr(py_obj);
    8263             :         PyObject *ret;
    8264             :         char *retstr;
    8265             : 
    8266           0 :         if (ndr_table_irpc.num_calls < 13) {
    8267           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_dnssrv_reload_dns_zones_ndr_print");
    8268           0 :                 return NULL;
    8269             :         }
    8270           0 :         call = &ndr_table_irpc.calls[12];
    8271             : 
    8272           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
    8273           0 :         ret = PyUnicode_FromString(retstr);
    8274           0 :         TALLOC_FREE(retstr);
    8275             : 
    8276           0 :         return ret;
    8277             : }
    8278             : 
    8279           0 : static PyObject *py_dnssrv_reload_dns_zones_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    8280             : {
    8281           0 :         return py_dnssrv_reload_dns_zones_ndr_print(py_obj, "dnssrv_reload_dns_zones_in", NDR_IN);
    8282             : }
    8283             : 
    8284           0 : static PyObject *py_dnssrv_reload_dns_zones_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    8285             : {
    8286           0 :         return py_dnssrv_reload_dns_zones_ndr_print(py_obj, "dnssrv_reload_dns_zones_out", NDR_OUT);
    8287             : }
    8288             : 
    8289             : static PyMethodDef py_dnssrv_reload_dns_zones_methods[] = {
    8290             :         { "opnum", (PyCFunction)py_dnssrv_reload_dns_zones_ndr_opnum, METH_NOARGS|METH_CLASS,
    8291             :                 "irpc.dnssrv_reload_dns_zones.opnum() -> 12 (0x0c) " },
    8292             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_dnssrv_reload_dns_zones_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
    8293             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
    8294             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_dnssrv_reload_dns_zones_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
    8295             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
    8296             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_dnssrv_reload_dns_zones_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
    8297             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
    8298             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_dnssrv_reload_dns_zones_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
    8299             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
    8300             :         { "__ndr_print_in__", (PyCFunction)py_dnssrv_reload_dns_zones_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
    8301             :         { "__ndr_print_out__", (PyCFunction)py_dnssrv_reload_dns_zones_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
    8302             :         { NULL, NULL, 0, NULL }
    8303             : };
    8304             : 
    8305             : 
    8306             : static PyTypeObject dnssrv_reload_dns_zones_Type = {
    8307             :         PyVarObject_HEAD_INIT(NULL, 0)
    8308             :         .tp_name = "irpc.dnssrv_reload_dns_zones",
    8309             :         .tp_getset = py_dnssrv_reload_dns_zones_getsetters,
    8310             :         .tp_methods = py_dnssrv_reload_dns_zones_methods,
    8311             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    8312             :         .tp_new = py_dnssrv_reload_dns_zones_new,
    8313             : };
    8314             : 
    8315           0 : static bool pack_py_dnssrv_reload_dns_zones_args_in(PyObject *args, PyObject *kwargs, struct dnssrv_reload_dns_zones *r)
    8316             : {
    8317           0 :         const char *kwnames[] = {
    8318             :                 NULL
    8319             :         };
    8320             : 
    8321           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, ":dnssrv_reload_dns_zones", discard_const_p(char *, kwnames))) {
    8322           0 :                 return false;
    8323             :         }
    8324             : 
    8325           0 :         return true;
    8326             : }
    8327             : 
    8328           0 : static PyObject *unpack_py_dnssrv_reload_dns_zones_args_out(struct dnssrv_reload_dns_zones *r)
    8329             : {
    8330             :         PyObject *result;
    8331           0 :         result = Py_None;
    8332           0 :         Py_INCREF(result);
    8333           0 :         if (NT_STATUS_IS_ERR(r->out.result)) {
    8334           0 :                 PyErr_SetNTSTATUS(r->out.result);
    8335           0 :                 return NULL;
    8336             :         }
    8337             : 
    8338           0 :         return result;
    8339             : }
    8340             : 
    8341             : const struct PyNdrRpcMethodDef py_ndr_irpc_methods[] = {
    8342             :         { "uptime", "S.uptime() -> start_time", (py_dcerpc_call_fn)dcerpc_irpc_uptime_r, (py_data_pack_fn)pack_py_irpc_uptime_args_in, (py_data_unpack_fn)unpack_py_irpc_uptime_args_out, 0, &ndr_table_irpc },
    8343             :         { "nbtd_information", "S.nbtd_information(level) -> info", (py_dcerpc_call_fn)dcerpc_nbtd_information_r, (py_data_pack_fn)pack_py_nbtd_information_args_in, (py_data_unpack_fn)unpack_py_nbtd_information_args_out, 1, &ndr_table_irpc },
    8344             :         { "nbtd_getdcname", "S.nbtd_getdcname(domainname, ip_address, my_computername, my_accountname, account_control, domain_sid) -> dcname", (py_dcerpc_call_fn)dcerpc_nbtd_getdcname_r, (py_data_pack_fn)pack_py_nbtd_getdcname_args_in, (py_data_unpack_fn)unpack_py_nbtd_getdcname_args_out, 2, &ndr_table_irpc },
    8345             :         { "nbtd_proxy_wins_challenge", "S.nbtd_proxy_wins_challenge(name, num_addrs, addrs) -> (num_addrs, addrs)", (py_dcerpc_call_fn)dcerpc_nbtd_proxy_wins_challenge_r, (py_data_pack_fn)pack_py_nbtd_proxy_wins_challenge_args_in, (py_data_unpack_fn)unpack_py_nbtd_proxy_wins_challenge_args_out, 3, &ndr_table_irpc },
    8346             :         { "nbtd_proxy_wins_release_demand", "S.nbtd_proxy_wins_release_demand(name, num_addrs, addrs) -> None", (py_dcerpc_call_fn)dcerpc_nbtd_proxy_wins_release_demand_r, (py_data_pack_fn)pack_py_nbtd_proxy_wins_release_demand_args_in, (py_data_unpack_fn)unpack_py_nbtd_proxy_wins_release_demand_args_out, 4, &ndr_table_irpc },
    8347             :         { "kdc_check_generic_kerberos", "S.kdc_check_generic_kerberos(generic_request) -> generic_reply", (py_dcerpc_call_fn)dcerpc_kdc_check_generic_kerberos_r, (py_data_pack_fn)pack_py_kdc_check_generic_kerberos_args_in, (py_data_unpack_fn)unpack_py_kdc_check_generic_kerberos_args_out, 5, &ndr_table_irpc },
    8348             :         { "smbsrv_information", "S.smbsrv_information(level) -> info", (py_dcerpc_call_fn)dcerpc_smbsrv_information_r, (py_data_pack_fn)pack_py_smbsrv_information_args_in, (py_data_unpack_fn)unpack_py_smbsrv_information_args_out, 6, &ndr_table_irpc },
    8349             :         { "samba_terminate", "S.samba_terminate(reason) -> None", (py_dcerpc_call_fn)dcerpc_samba_terminate_r, (py_data_pack_fn)pack_py_samba_terminate_args_in, (py_data_unpack_fn)unpack_py_samba_terminate_args_out, 7, &ndr_table_irpc },
    8350             :         { "dreplsrv_refresh", "S.dreplsrv_refresh() -> None", (py_dcerpc_call_fn)dcerpc_dreplsrv_refresh_r, (py_data_pack_fn)pack_py_dreplsrv_refresh_args_in, (py_data_unpack_fn)unpack_py_dreplsrv_refresh_args_out, 8, &ndr_table_irpc },
    8351             :         { "drepl_takeFSMORole", "S.drepl_takeFSMORole(role) -> None", (py_dcerpc_call_fn)dcerpc_drepl_takeFSMORole_r, (py_data_pack_fn)pack_py_drepl_takeFSMORole_args_in, (py_data_unpack_fn)unpack_py_drepl_takeFSMORole_args_out, 9, &ndr_table_irpc },
    8352             :         { "drepl_trigger_repl_secret", "S.drepl_trigger_repl_secret(user_dn) -> None", (py_dcerpc_call_fn)dcerpc_drepl_trigger_repl_secret_r, (py_data_pack_fn)pack_py_drepl_trigger_repl_secret_args_in, (py_data_unpack_fn)unpack_py_drepl_trigger_repl_secret_args_out, 10, &ndr_table_irpc },
    8353             :         { "dnsupdate_RODC", "S.dnsupdate_RODC(dom_sid, site_name, dns_ttl, dns_names) -> dns_names", (py_dcerpc_call_fn)dcerpc_dnsupdate_RODC_r, (py_data_pack_fn)pack_py_dnsupdate_RODC_args_in, (py_data_unpack_fn)unpack_py_dnsupdate_RODC_args_out, 11, &ndr_table_irpc },
    8354             :         { "dnssrv_reload_dns_zones", "S.dnssrv_reload_dns_zones() -> None", (py_dcerpc_call_fn)dcerpc_dnssrv_reload_dns_zones_r, (py_data_pack_fn)pack_py_dnssrv_reload_dns_zones_args_in, (py_data_unpack_fn)unpack_py_dnssrv_reload_dns_zones_args_out, 12, &ndr_table_irpc },
    8355             :         {0}
    8356             : };
    8357             : 
    8358           0 : static PyObject *interface_irpc_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    8359             : {
    8360           0 :         return py_dcerpc_interface_init_helper(type, args, kwargs, &ndr_table_irpc);
    8361             : }
    8362             : 
    8363             : static PyTypeObject irpc_InterfaceType = {
    8364             :         PyVarObject_HEAD_INIT(NULL, 0)
    8365             :         .tp_name = "irpc.irpc",
    8366             :         .tp_basicsize = sizeof(dcerpc_InterfaceObject),
    8367             :         .tp_doc = "irpc(binding, lp_ctx=None, credentials=None) -> connection\n"
    8368             : "\n"
    8369             : "binding should be a DCE/RPC binding string (for example: ncacn_ip_tcp:127.0.0.1)\n"
    8370             : "lp_ctx should be a path to a smb.conf file or a param.LoadParm object\n"
    8371             : "credentials should be a credentials.Credentials object.\n\n",
    8372             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    8373             :         .tp_new = interface_irpc_new,
    8374             : };
    8375             : 
    8376           0 : static PyObject *syntax_irpc_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    8377             : {
    8378           0 :         return py_dcerpc_syntax_init_helper(type, args, kwargs, &ndr_table_irpc.syntax_id);
    8379             : }
    8380             : 
    8381             : static PyTypeObject irpc_SyntaxType = {
    8382             :         PyVarObject_HEAD_INIT(NULL, 0)
    8383             :         .tp_name = "irpc.irpc_abstract_syntax",
    8384             :         .tp_doc = "irpc_abstract_syntax()\n",
    8385             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    8386             :         .tp_new = syntax_irpc_new,
    8387             : };
    8388             : 
    8389             : static PyMethodDef irpc_methods[] = {
    8390             :         { NULL, NULL, 0, NULL }
    8391             : };
    8392             : 
    8393             : static struct PyModuleDef moduledef = {
    8394             :         PyModuleDef_HEAD_INIT,
    8395             :         .m_name = "irpc",
    8396             :         .m_doc = "irpc DCE/RPC",
    8397             :         .m_size = -1,
    8398             :         .m_methods = irpc_methods,
    8399             : };
    8400          12 : MODULE_INIT_FUNC(irpc)
    8401             : {
    8402          12 :         PyObject *m = NULL;
    8403          12 :         PyObject *dep_samba_dcerpc_misc = NULL;
    8404          12 :         PyObject *dep_samba_dcerpc_security = NULL;
    8405          12 :         PyObject *dep_samba_dcerpc_nbt = NULL;
    8406          12 :         PyObject *dep_samba_dcerpc_netlogon = NULL;
    8407          12 :         PyObject *dep_samba_dcerpc_server_id = NULL;
    8408          12 :         PyObject *dep_talloc = NULL;
    8409          12 :         PyObject *dep_samba_dcerpc_base = NULL;
    8410             : 
    8411          12 :         dep_samba_dcerpc_misc = PyImport_ImportModule("samba.dcerpc.misc");
    8412          12 :         if (dep_samba_dcerpc_misc == NULL)
    8413           0 :                 goto out;
    8414             : 
    8415          12 :         dep_samba_dcerpc_security = PyImport_ImportModule("samba.dcerpc.security");
    8416          12 :         if (dep_samba_dcerpc_security == NULL)
    8417           0 :                 goto out;
    8418             : 
    8419          12 :         dep_samba_dcerpc_nbt = PyImport_ImportModule("samba.dcerpc.nbt");
    8420          12 :         if (dep_samba_dcerpc_nbt == NULL)
    8421           0 :                 goto out;
    8422             : 
    8423          12 :         dep_samba_dcerpc_netlogon = PyImport_ImportModule("samba.dcerpc.netlogon");
    8424          12 :         if (dep_samba_dcerpc_netlogon == NULL)
    8425           0 :                 goto out;
    8426             : 
    8427          12 :         dep_samba_dcerpc_server_id = PyImport_ImportModule("samba.dcerpc.server_id");
    8428          12 :         if (dep_samba_dcerpc_server_id == NULL)
    8429           0 :                 goto out;
    8430             : 
    8431          12 :         dep_talloc = PyImport_ImportModule("talloc");
    8432          12 :         if (dep_talloc == NULL)
    8433           0 :                 goto out;
    8434             : 
    8435          12 :         dep_samba_dcerpc_base = PyImport_ImportModule("samba.dcerpc.base");
    8436          12 :         if (dep_samba_dcerpc_base == NULL)
    8437           0 :                 goto out;
    8438             : 
    8439          12 :         security_token_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_security, "token");
    8440          12 :         if (security_token_Type == NULL)
    8441           0 :                 goto out;
    8442             : 
    8443          12 :         BaseObject_Type = (PyTypeObject *)PyObject_GetAttrString(dep_talloc, "BaseObject");
    8444          12 :         if (BaseObject_Type == NULL)
    8445           0 :                 goto out;
    8446             : 
    8447          12 :         GUID_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_misc, "GUID");
    8448          12 :         if (GUID_Type == NULL)
    8449           0 :                 goto out;
    8450             : 
    8451          12 :         server_id_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_server_id, "server_id");
    8452          12 :         if (server_id_Type == NULL)
    8453           0 :                 goto out;
    8454             : 
    8455          12 :         dom_sid_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_security, "dom_sid");
    8456          12 :         if (dom_sid_Type == NULL)
    8457           0 :                 goto out;
    8458             : 
    8459          12 :         nbt_name_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_nbt, "name");
    8460          12 :         if (nbt_name_Type == NULL)
    8461           0 :                 goto out;
    8462             : 
    8463          12 :         NL_DNS_NAME_INFO_ARRAY_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_netlogon, "NL_DNS_NAME_INFO_ARRAY");
    8464          12 :         if (NL_DNS_NAME_INFO_ARRAY_Type == NULL)
    8465           0 :                 goto out;
    8466             : 
    8467          12 :         ClientConnection_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_base, "ClientConnection");
    8468          12 :         if (ClientConnection_Type == NULL)
    8469           0 :                 goto out;
    8470             : 
    8471          12 :         ndr_syntax_id_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_misc, "ndr_syntax_id");
    8472          12 :         if (ndr_syntax_id_Type == NULL)
    8473           0 :                 goto out;
    8474             : 
    8475          12 :         irpc_creds_Type.tp_base = BaseObject_Type;
    8476          12 :         irpc_creds_Type.tp_basicsize = pytalloc_BaseObject_size();
    8477             : 
    8478          12 :         irpc_header_Type.tp_base = BaseObject_Type;
    8479          12 :         irpc_header_Type.tp_basicsize = pytalloc_BaseObject_size();
    8480             : 
    8481          12 :         irpc_name_record_Type.tp_base = BaseObject_Type;
    8482          12 :         irpc_name_record_Type.tp_basicsize = pytalloc_BaseObject_size();
    8483             : 
    8484          12 :         irpc_name_records_Type.tp_base = BaseObject_Type;
    8485          12 :         irpc_name_records_Type.tp_basicsize = pytalloc_BaseObject_size();
    8486             : 
    8487          12 :         nbtd_statistics_Type.tp_base = BaseObject_Type;
    8488          12 :         nbtd_statistics_Type.tp_basicsize = pytalloc_BaseObject_size();
    8489             : 
    8490          12 :         nbtd_info_Type.tp_base = BaseObject_Type;
    8491          12 :         nbtd_info_Type.tp_basicsize = pytalloc_BaseObject_size();
    8492             : 
    8493          12 :         nbtd_proxy_wins_addr_Type.tp_base = BaseObject_Type;
    8494          12 :         nbtd_proxy_wins_addr_Type.tp_basicsize = pytalloc_BaseObject_size();
    8495             : 
    8496          12 :         smbsrv_session_info_Type.tp_base = BaseObject_Type;
    8497          12 :         smbsrv_session_info_Type.tp_basicsize = pytalloc_BaseObject_size();
    8498             : 
    8499          12 :         smbsrv_sessions_Type.tp_base = BaseObject_Type;
    8500          12 :         smbsrv_sessions_Type.tp_basicsize = pytalloc_BaseObject_size();
    8501             : 
    8502          12 :         smbsrv_tcon_info_Type.tp_base = BaseObject_Type;
    8503          12 :         smbsrv_tcon_info_Type.tp_basicsize = pytalloc_BaseObject_size();
    8504             : 
    8505          12 :         smbsrv_tcons_Type.tp_base = BaseObject_Type;
    8506          12 :         smbsrv_tcons_Type.tp_basicsize = pytalloc_BaseObject_size();
    8507             : 
    8508          12 :         smbsrv_info_Type.tp_base = BaseObject_Type;
    8509          12 :         smbsrv_info_Type.tp_basicsize = pytalloc_BaseObject_size();
    8510             : 
    8511          12 :         irpc_uptime_Type.tp_base = BaseObject_Type;
    8512          12 :         irpc_uptime_Type.tp_basicsize = pytalloc_BaseObject_size();
    8513             : 
    8514          12 :         nbtd_information_Type.tp_base = BaseObject_Type;
    8515          12 :         nbtd_information_Type.tp_basicsize = pytalloc_BaseObject_size();
    8516             : 
    8517          12 :         nbtd_getdcname_Type.tp_base = BaseObject_Type;
    8518          12 :         nbtd_getdcname_Type.tp_basicsize = pytalloc_BaseObject_size();
    8519             : 
    8520          12 :         nbtd_proxy_wins_challenge_Type.tp_base = BaseObject_Type;
    8521          12 :         nbtd_proxy_wins_challenge_Type.tp_basicsize = pytalloc_BaseObject_size();
    8522             : 
    8523          12 :         nbtd_proxy_wins_release_demand_Type.tp_base = BaseObject_Type;
    8524          12 :         nbtd_proxy_wins_release_demand_Type.tp_basicsize = pytalloc_BaseObject_size();
    8525             : 
    8526          12 :         kdc_check_generic_kerberos_Type.tp_base = BaseObject_Type;
    8527          12 :         kdc_check_generic_kerberos_Type.tp_basicsize = pytalloc_BaseObject_size();
    8528             : 
    8529          12 :         smbsrv_information_Type.tp_base = BaseObject_Type;
    8530          12 :         smbsrv_information_Type.tp_basicsize = pytalloc_BaseObject_size();
    8531             : 
    8532          12 :         samba_terminate_Type.tp_base = BaseObject_Type;
    8533          12 :         samba_terminate_Type.tp_basicsize = pytalloc_BaseObject_size();
    8534             : 
    8535          12 :         dreplsrv_refresh_Type.tp_base = BaseObject_Type;
    8536          12 :         dreplsrv_refresh_Type.tp_basicsize = pytalloc_BaseObject_size();
    8537             : 
    8538          12 :         drepl_takeFSMORole_Type.tp_base = BaseObject_Type;
    8539          12 :         drepl_takeFSMORole_Type.tp_basicsize = pytalloc_BaseObject_size();
    8540             : 
    8541          12 :         drepl_trigger_repl_secret_Type.tp_base = BaseObject_Type;
    8542          12 :         drepl_trigger_repl_secret_Type.tp_basicsize = pytalloc_BaseObject_size();
    8543             : 
    8544          12 :         dnsupdate_RODC_Type.tp_base = BaseObject_Type;
    8545          12 :         dnsupdate_RODC_Type.tp_basicsize = pytalloc_BaseObject_size();
    8546             : 
    8547          12 :         dnssrv_reload_dns_zones_Type.tp_base = BaseObject_Type;
    8548          12 :         dnssrv_reload_dns_zones_Type.tp_basicsize = pytalloc_BaseObject_size();
    8549             : 
    8550          12 :         irpc_InterfaceType.tp_base = ClientConnection_Type;
    8551             : 
    8552          12 :         irpc_SyntaxType.tp_base = ndr_syntax_id_Type;
    8553          12 :         irpc_SyntaxType.tp_basicsize = pytalloc_BaseObject_size();
    8554             : 
    8555          12 :         if (PyType_Ready(&irpc_creds_Type) < 0)
    8556           0 :                 goto out;
    8557          12 :         if (PyType_Ready(&irpc_header_Type) < 0)
    8558           0 :                 goto out;
    8559          12 :         if (PyType_Ready(&irpc_name_record_Type) < 0)
    8560           0 :                 goto out;
    8561          12 :         if (PyType_Ready(&irpc_name_records_Type) < 0)
    8562           0 :                 goto out;
    8563          12 :         if (PyType_Ready(&nbtd_statistics_Type) < 0)
    8564           0 :                 goto out;
    8565          12 :         if (PyType_Ready(&nbtd_info_Type) < 0)
    8566           0 :                 goto out;
    8567          12 :         if (PyType_Ready(&nbtd_proxy_wins_addr_Type) < 0)
    8568           0 :                 goto out;
    8569          12 :         if (PyType_Ready(&smbsrv_session_info_Type) < 0)
    8570           0 :                 goto out;
    8571          12 :         if (PyType_Ready(&smbsrv_sessions_Type) < 0)
    8572           0 :                 goto out;
    8573          12 :         if (PyType_Ready(&smbsrv_tcon_info_Type) < 0)
    8574           0 :                 goto out;
    8575          12 :         if (PyType_Ready(&smbsrv_tcons_Type) < 0)
    8576           0 :                 goto out;
    8577          12 :         if (PyType_Ready(&smbsrv_info_Type) < 0)
    8578           0 :                 goto out;
    8579          12 :         if (PyType_Ready(&irpc_uptime_Type) < 0)
    8580           0 :                 goto out;
    8581          12 :         if (PyType_Ready(&nbtd_information_Type) < 0)
    8582           0 :                 goto out;
    8583          12 :         if (PyType_Ready(&nbtd_getdcname_Type) < 0)
    8584           0 :                 goto out;
    8585          12 :         if (PyType_Ready(&nbtd_proxy_wins_challenge_Type) < 0)
    8586           0 :                 goto out;
    8587          12 :         if (PyType_Ready(&nbtd_proxy_wins_release_demand_Type) < 0)
    8588           0 :                 goto out;
    8589          12 :         if (PyType_Ready(&kdc_check_generic_kerberos_Type) < 0)
    8590           0 :                 goto out;
    8591          12 :         if (PyType_Ready(&smbsrv_information_Type) < 0)
    8592           0 :                 goto out;
    8593          12 :         if (PyType_Ready(&samba_terminate_Type) < 0)
    8594           0 :                 goto out;
    8595          12 :         if (PyType_Ready(&dreplsrv_refresh_Type) < 0)
    8596           0 :                 goto out;
    8597          12 :         if (PyType_Ready(&drepl_takeFSMORole_Type) < 0)
    8598           0 :                 goto out;
    8599          12 :         if (PyType_Ready(&drepl_trigger_repl_secret_Type) < 0)
    8600           0 :                 goto out;
    8601          12 :         if (PyType_Ready(&dnsupdate_RODC_Type) < 0)
    8602           0 :                 goto out;
    8603          12 :         if (PyType_Ready(&dnssrv_reload_dns_zones_Type) < 0)
    8604           0 :                 goto out;
    8605          12 :         if (PyType_Ready(&irpc_InterfaceType) < 0)
    8606           0 :                 goto out;
    8607          12 :         if (PyType_Ready(&irpc_SyntaxType) < 0)
    8608           0 :                 goto out;
    8609          12 :         if (!PyInterface_AddNdrRpcMethods(&irpc_InterfaceType, py_ndr_irpc_methods))
    8610           0 :                 return NULL;
    8611             : 
    8612             : #ifdef PY_CREDS_PATCH
    8613             :         PY_CREDS_PATCH(&irpc_creds_Type);
    8614             : #endif
    8615             : #ifdef PY_HEADER_PATCH
    8616             :         PY_HEADER_PATCH(&irpc_header_Type);
    8617             : #endif
    8618             : #ifdef PY_NAME_RECORD_PATCH
    8619             :         PY_NAME_RECORD_PATCH(&irpc_name_record_Type);
    8620             : #endif
    8621             : #ifdef PY_NAME_RECORDS_PATCH
    8622             :         PY_NAME_RECORDS_PATCH(&irpc_name_records_Type);
    8623             : #endif
    8624             : #ifdef PY_NBTD_STATISTICS_PATCH
    8625             :         PY_NBTD_STATISTICS_PATCH(&nbtd_statistics_Type);
    8626             : #endif
    8627             : #ifdef PY_NBTD_INFO_PATCH
    8628             :         PY_NBTD_INFO_PATCH(&nbtd_info_Type);
    8629             : #endif
    8630             : #ifdef PY_NBTD_PROXY_WINS_ADDR_PATCH
    8631             :         PY_NBTD_PROXY_WINS_ADDR_PATCH(&nbtd_proxy_wins_addr_Type);
    8632             : #endif
    8633             : #ifdef PY_SMBSRV_SESSION_INFO_PATCH
    8634             :         PY_SMBSRV_SESSION_INFO_PATCH(&smbsrv_session_info_Type);
    8635             : #endif
    8636             : #ifdef PY_SMBSRV_SESSIONS_PATCH
    8637             :         PY_SMBSRV_SESSIONS_PATCH(&smbsrv_sessions_Type);
    8638             : #endif
    8639             : #ifdef PY_SMBSRV_TCON_INFO_PATCH
    8640             :         PY_SMBSRV_TCON_INFO_PATCH(&smbsrv_tcon_info_Type);
    8641             : #endif
    8642             : #ifdef PY_SMBSRV_TCONS_PATCH
    8643             :         PY_SMBSRV_TCONS_PATCH(&smbsrv_tcons_Type);
    8644             : #endif
    8645             : #ifdef PY_SMBSRV_INFO_PATCH
    8646             :         PY_SMBSRV_INFO_PATCH(&smbsrv_info_Type);
    8647             : #endif
    8648             : #ifdef PY_UPTIME_PATCH
    8649             :         PY_UPTIME_PATCH(&irpc_uptime_Type);
    8650             : #endif
    8651             : #ifdef PY_NBTD_INFORMATION_PATCH
    8652             :         PY_NBTD_INFORMATION_PATCH(&nbtd_information_Type);
    8653             : #endif
    8654             : #ifdef PY_NBTD_GETDCNAME_PATCH
    8655             :         PY_NBTD_GETDCNAME_PATCH(&nbtd_getdcname_Type);
    8656             : #endif
    8657             : #ifdef PY_NBTD_PROXY_WINS_CHALLENGE_PATCH
    8658             :         PY_NBTD_PROXY_WINS_CHALLENGE_PATCH(&nbtd_proxy_wins_challenge_Type);
    8659             : #endif
    8660             : #ifdef PY_NBTD_PROXY_WINS_RELEASE_DEMAND_PATCH
    8661             :         PY_NBTD_PROXY_WINS_RELEASE_DEMAND_PATCH(&nbtd_proxy_wins_release_demand_Type);
    8662             : #endif
    8663             : #ifdef PY_KDC_CHECK_GENERIC_KERBEROS_PATCH
    8664             :         PY_KDC_CHECK_GENERIC_KERBEROS_PATCH(&kdc_check_generic_kerberos_Type);
    8665             : #endif
    8666             : #ifdef PY_SMBSRV_INFORMATION_PATCH
    8667             :         PY_SMBSRV_INFORMATION_PATCH(&smbsrv_information_Type);
    8668             : #endif
    8669             : #ifdef PY_SAMBA_TERMINATE_PATCH
    8670             :         PY_SAMBA_TERMINATE_PATCH(&samba_terminate_Type);
    8671             : #endif
    8672             : #ifdef PY_DREPLSRV_REFRESH_PATCH
    8673             :         PY_DREPLSRV_REFRESH_PATCH(&dreplsrv_refresh_Type);
    8674             : #endif
    8675             : #ifdef PY_DREPL_TAKEFSMOROLE_PATCH
    8676             :         PY_DREPL_TAKEFSMOROLE_PATCH(&drepl_takeFSMORole_Type);
    8677             : #endif
    8678             : #ifdef PY_DREPL_TRIGGER_REPL_SECRET_PATCH
    8679             :         PY_DREPL_TRIGGER_REPL_SECRET_PATCH(&drepl_trigger_repl_secret_Type);
    8680             : #endif
    8681             : #ifdef PY_DNSUPDATE_RODC_PATCH
    8682             :         PY_DNSUPDATE_RODC_PATCH(&dnsupdate_RODC_Type);
    8683             : #endif
    8684             : #ifdef PY_DNSSRV_RELOAD_DNS_ZONES_PATCH
    8685             :         PY_DNSSRV_RELOAD_DNS_ZONES_PATCH(&dnssrv_reload_dns_zones_Type);
    8686             : #endif
    8687             : #ifdef PY_IRPC_PATCH
    8688             :         PY_IRPC_PATCH(&irpc_InterfaceType);
    8689             : #endif
    8690             : #ifdef PY_IRPC_ABSTRACT_SYNTAX_PATCH
    8691             :         PY_IRPC_ABSTRACT_SYNTAX_PATCH(&irpc_SyntaxType);
    8692             : #endif
    8693             : #ifdef PY_ABSTRACT_SYNTAX_PATCH
    8694             :         PY_ABSTRACT_SYNTAX_PATCH(&irpc_SyntaxType);
    8695             : #endif
    8696             : 
    8697          12 :         m = PyModule_Create(&moduledef);
    8698          12 :         if (m == NULL)
    8699           0 :                 goto out;
    8700             : 
    8701          12 :         PyModule_AddObject(m, "IRPC_FLAG_REPLY", PyLong_FromUnsignedLongLong((uint32_t)(IRPC_FLAG_REPLY)));
    8702          12 :         PyModule_AddObject(m, "NBTD_INFO_STATISTICS", PyLong_FromUnsignedLongLong((uint32_t)(NBTD_INFO_STATISTICS)));
    8703          12 :         PyModule_AddObject(m, "SMBSRV_INFO_SESSIONS", PyLong_FromUnsignedLongLong((uint32_t)(SMBSRV_INFO_SESSIONS)));
    8704          12 :         PyModule_AddObject(m, "SMBSRV_INFO_TCONS", PyLong_FromUnsignedLongLong((uint32_t)(SMBSRV_INFO_TCONS)));
    8705          12 :         PyModule_AddObject(m, "DREPL_SCHEMA_MASTER", PyLong_FromUnsignedLongLong((uint32_t)(DREPL_SCHEMA_MASTER)));
    8706          12 :         PyModule_AddObject(m, "DREPL_RID_MASTER", PyLong_FromUnsignedLongLong((uint32_t)(DREPL_RID_MASTER)));
    8707          12 :         PyModule_AddObject(m, "DREPL_INFRASTRUCTURE_MASTER", PyLong_FromUnsignedLongLong((uint32_t)(DREPL_INFRASTRUCTURE_MASTER)));
    8708          12 :         PyModule_AddObject(m, "DREPL_NAMING_MASTER", PyLong_FromUnsignedLongLong((uint32_t)(DREPL_NAMING_MASTER)));
    8709          12 :         PyModule_AddObject(m, "DREPL_PDC_MASTER", PyLong_FromUnsignedLongLong((uint32_t)(DREPL_PDC_MASTER)));
    8710           9 :         Py_INCREF((PyObject *)(void *)&irpc_creds_Type);
    8711          12 :         PyModule_AddObject(m, "creds", (PyObject *)(void *)&irpc_creds_Type);
    8712           9 :         Py_INCREF((PyObject *)(void *)&irpc_header_Type);
    8713          12 :         PyModule_AddObject(m, "header", (PyObject *)(void *)&irpc_header_Type);
    8714           9 :         Py_INCREF((PyObject *)(void *)&irpc_name_record_Type);
    8715          12 :         PyModule_AddObject(m, "name_record", (PyObject *)(void *)&irpc_name_record_Type);
    8716           9 :         Py_INCREF((PyObject *)(void *)&irpc_name_records_Type);
    8717          12 :         PyModule_AddObject(m, "name_records", (PyObject *)(void *)&irpc_name_records_Type);
    8718           9 :         Py_INCREF((PyObject *)(void *)&nbtd_statistics_Type);
    8719          12 :         PyModule_AddObject(m, "nbtd_statistics", (PyObject *)(void *)&nbtd_statistics_Type);
    8720           9 :         Py_INCREF((PyObject *)(void *)&nbtd_info_Type);
    8721          12 :         PyModule_AddObject(m, "nbtd_info", (PyObject *)(void *)&nbtd_info_Type);
    8722           9 :         Py_INCREF((PyObject *)(void *)&nbtd_proxy_wins_addr_Type);
    8723          12 :         PyModule_AddObject(m, "nbtd_proxy_wins_addr", (PyObject *)(void *)&nbtd_proxy_wins_addr_Type);
    8724           9 :         Py_INCREF((PyObject *)(void *)&smbsrv_session_info_Type);
    8725          12 :         PyModule_AddObject(m, "smbsrv_session_info", (PyObject *)(void *)&smbsrv_session_info_Type);
    8726           9 :         Py_INCREF((PyObject *)(void *)&smbsrv_sessions_Type);
    8727          12 :         PyModule_AddObject(m, "smbsrv_sessions", (PyObject *)(void *)&smbsrv_sessions_Type);
    8728           9 :         Py_INCREF((PyObject *)(void *)&smbsrv_tcon_info_Type);
    8729          12 :         PyModule_AddObject(m, "smbsrv_tcon_info", (PyObject *)(void *)&smbsrv_tcon_info_Type);
    8730           9 :         Py_INCREF((PyObject *)(void *)&smbsrv_tcons_Type);
    8731          12 :         PyModule_AddObject(m, "smbsrv_tcons", (PyObject *)(void *)&smbsrv_tcons_Type);
    8732           9 :         Py_INCREF((PyObject *)(void *)&smbsrv_info_Type);
    8733          12 :         PyModule_AddObject(m, "smbsrv_info", (PyObject *)(void *)&smbsrv_info_Type);
    8734           9 :         Py_INCREF((PyObject *)(void *)&irpc_uptime_Type);
    8735          12 :         PyModule_AddObject(m, "uptime", (PyObject *)(void *)&irpc_uptime_Type);
    8736           9 :         Py_INCREF((PyObject *)(void *)&nbtd_information_Type);
    8737          12 :         PyModule_AddObject(m, "nbtd_information", (PyObject *)(void *)&nbtd_information_Type);
    8738           9 :         Py_INCREF((PyObject *)(void *)&nbtd_getdcname_Type);
    8739          12 :         PyModule_AddObject(m, "nbtd_getdcname", (PyObject *)(void *)&nbtd_getdcname_Type);
    8740           9 :         Py_INCREF((PyObject *)(void *)&nbtd_proxy_wins_challenge_Type);
    8741          12 :         PyModule_AddObject(m, "nbtd_proxy_wins_challenge", (PyObject *)(void *)&nbtd_proxy_wins_challenge_Type);
    8742           9 :         Py_INCREF((PyObject *)(void *)&nbtd_proxy_wins_release_demand_Type);
    8743          12 :         PyModule_AddObject(m, "nbtd_proxy_wins_release_demand", (PyObject *)(void *)&nbtd_proxy_wins_release_demand_Type);
    8744           9 :         Py_INCREF((PyObject *)(void *)&kdc_check_generic_kerberos_Type);
    8745          12 :         PyModule_AddObject(m, "kdc_check_generic_kerberos", (PyObject *)(void *)&kdc_check_generic_kerberos_Type);
    8746           9 :         Py_INCREF((PyObject *)(void *)&smbsrv_information_Type);
    8747          12 :         PyModule_AddObject(m, "smbsrv_information", (PyObject *)(void *)&smbsrv_information_Type);
    8748           9 :         Py_INCREF((PyObject *)(void *)&samba_terminate_Type);
    8749          12 :         PyModule_AddObject(m, "samba_terminate", (PyObject *)(void *)&samba_terminate_Type);
    8750           9 :         Py_INCREF((PyObject *)(void *)&dreplsrv_refresh_Type);
    8751          12 :         PyModule_AddObject(m, "dreplsrv_refresh", (PyObject *)(void *)&dreplsrv_refresh_Type);
    8752           9 :         Py_INCREF((PyObject *)(void *)&drepl_takeFSMORole_Type);
    8753          12 :         PyModule_AddObject(m, "drepl_takeFSMORole", (PyObject *)(void *)&drepl_takeFSMORole_Type);
    8754           9 :         Py_INCREF((PyObject *)(void *)&drepl_trigger_repl_secret_Type);
    8755          12 :         PyModule_AddObject(m, "drepl_trigger_repl_secret", (PyObject *)(void *)&drepl_trigger_repl_secret_Type);
    8756           9 :         Py_INCREF((PyObject *)(void *)&dnsupdate_RODC_Type);
    8757          12 :         PyModule_AddObject(m, "dnsupdate_RODC", (PyObject *)(void *)&dnsupdate_RODC_Type);
    8758           9 :         Py_INCREF((PyObject *)(void *)&dnssrv_reload_dns_zones_Type);
    8759          12 :         PyModule_AddObject(m, "dnssrv_reload_dns_zones", (PyObject *)(void *)&dnssrv_reload_dns_zones_Type);
    8760           9 :         Py_INCREF((PyObject *)(void *)&irpc_InterfaceType);
    8761          12 :         PyModule_AddObject(m, "irpc", (PyObject *)(void *)&irpc_InterfaceType);
    8762           9 :         Py_INCREF((PyObject *)(void *)&irpc_SyntaxType);
    8763          12 :         PyModule_AddObject(m, "irpc_abstract_syntax", (PyObject *)(void *)&irpc_SyntaxType);
    8764           9 :         Py_INCREF((PyObject *)(void *)&irpc_SyntaxType);
    8765          12 :         PyModule_AddObject(m, "abstract_syntax", (PyObject *)(void *)&irpc_SyntaxType);
    8766             : #ifdef PY_MOD_IRPC_PATCH
    8767             :         PY_MOD_IRPC_PATCH(m);
    8768             : #endif
    8769          12 :         out:
    8770          12 :         Py_XDECREF(dep_samba_dcerpc_misc);
    8771          12 :         Py_XDECREF(dep_samba_dcerpc_security);
    8772          12 :         Py_XDECREF(dep_samba_dcerpc_nbt);
    8773          12 :         Py_XDECREF(dep_samba_dcerpc_netlogon);
    8774          12 :         Py_XDECREF(dep_samba_dcerpc_server_id);
    8775          12 :         Py_XDECREF(dep_talloc);
    8776          12 :         Py_XDECREF(dep_samba_dcerpc_base);
    8777          12 :         return m;
    8778             : 
    8779             : }

Generated by: LCOV version 1.14