LCOV - code coverage report
Current view: top level - bin/default/librpc/gen_ndr - py_dnsserver.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 2333 19178 12.2 %
Date: 2021-09-23 10:06:22 Functions: 257 1367 18.8 %

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