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 master 2b515b7d Lines: 2356 20574 11.5 %
Date: 2024-02-28 12:06:22 Functions: 262 1366 19.2 %

          Line data    Source code
       1             : 
       2             : /* Python wrapper functions auto-generated by pidl */
       3             : #define PY_SSIZE_T_CLEAN 1 /* We use Py_ssize_t for PyArg_ParseTupleAndKeywords */
       4             : #include "lib/replace/system/python.h"
       5             : #include "python/py3compat.h"
       6             : #include "includes.h"
       7             : #include "python/modules.h"
       8             : #include <pytalloc.h>
       9             : #include "librpc/rpc/pyrpc.h"
      10             : #include "librpc/rpc/pyrpc_util.h"
      11             : #include "bin/default/librpc/gen_ndr/ndr_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       45918 : static inline unsigned long long ndr_sizeof2uintmax(size_t var_size)
      33             : {
      34       45918 :         switch (var_size) {
      35           0 :         case 8:
      36           0 :                 return UINT64_MAX;
      37       40542 :         case 4:
      38       40542 :                 return UINT32_MAX;
      39        2200 :         case 2:
      40        2200 :                 return UINT16_MAX;
      41        3176 :         case 1:
      42        3176 :                 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 = pytalloc_get_ptr(obj);
     137           0 :         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 = pytalloc_get_ptr(py_obj);
     145           0 :         if (value == NULL) {
     146           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: 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           0 :                         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 = pytalloc_get_ptr(obj);
     175           0 :         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           0 :                         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 = pytalloc_get_ptr(py_obj);
     194           0 :         if (value == NULL) {
     195           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->Buffer");
     196           0 :                 return -1;
     197             :         }
     198           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
     199             :         {
     200           0 :                 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: (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           0 :                                         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 = pytalloc_get_ptr(obj);
     269           0 :         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 = pytalloc_get_ptr(py_obj);
     277           0 :         if (value == NULL) {
     278           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: 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           0 :                         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 = pytalloc_get_ptr(obj);
     307           0 :         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           0 :                         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 = pytalloc_get_ptr(py_obj);
     336           0 :         if (value == NULL) {
     337           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszStrings");
     338           0 :                 return -1;
     339             :         }
     340           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
     341             :         {
     342           0 :                 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: (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           0 :                                         const char *test_str;
     357           0 :                                         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 :                                                         return -1;
     363             :                                                 }
     364           0 :                                                 test_str = PyBytes_AS_STRING(unicode);
     365           0 :                                         } else if (PyBytes_Check(PyList_GET_ITEM(value, pszStrings_cntr_0))) {
     366           0 :                                                 test_str = PyBytes_AS_STRING(PyList_GET_ITEM(value, pszStrings_cntr_0));
     367             :                                         } else {
     368           0 :                                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(PyList_GET_ITEM(value, pszStrings_cntr_0))->tp_name);
     369           0 :                                                 return -1;
     370             :                                         }
     371           0 :                                         talloc_str = talloc_strdup(object->pszStrings, test_str);
     372           0 :                                         if (unicode != NULL) {
     373           0 :                                                 Py_DECREF(unicode);
     374             :                                         }
     375           0 :                                         if (talloc_str == NULL) {
     376           0 :                                                 PyErr_NoMemory();
     377           0 :                                                 return -1;
     378             :                                         }
     379           0 :                                         (object->pszStrings)[pszStrings_cntr_0] = talloc_str;
     380             :                                 }
     381             :                         }
     382             :                 }
     383             :         }
     384           0 :         return 0;
     385             : }
     386             : 
     387             : static PyGetSetDef py_DNS_RPC_UTF8_STRING_LIST_getsetters[] = {
     388             :         {
     389             :                 .name = discard_const_p(char, "dwCount"),
     390             :                 .get = py_DNS_RPC_UTF8_STRING_LIST_get_dwCount,
     391             :                 .set = py_DNS_RPC_UTF8_STRING_LIST_set_dwCount,
     392             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
     393             :         },
     394             :         {
     395             :                 .name = discard_const_p(char, "pszStrings"),
     396             :                 .get = py_DNS_RPC_UTF8_STRING_LIST_get_pszStrings,
     397             :                 .set = py_DNS_RPC_UTF8_STRING_LIST_set_pszStrings,
     398             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
     399             :         },
     400             :         { .name = NULL }
     401             : };
     402             : 
     403           0 : static PyObject *py_DNS_RPC_UTF8_STRING_LIST_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     404             : {
     405           0 :         return pytalloc_new(struct DNS_RPC_UTF8_STRING_LIST, type);
     406             : }
     407             : 
     408             : 
     409             : static PyTypeObject DNS_RPC_UTF8_STRING_LIST_Type = {
     410             :         PyVarObject_HEAD_INIT(NULL, 0)
     411             :         .tp_name = "dnsserver.DNS_RPC_UTF8_STRING_LIST",
     412             :         .tp_getset = py_DNS_RPC_UTF8_STRING_LIST_getsetters,
     413             :         .tp_methods = NULL,
     414             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     415             :         .tp_new = py_DNS_RPC_UTF8_STRING_LIST_new,
     416             : };
     417             : 
     418             : 
     419           0 : static PyObject *py_DNS_RPC_NAME_AND_PARAM_get_dwParam(PyObject *obj, void *closure)
     420             : {
     421           0 :         struct DNS_RPC_NAME_AND_PARAM *object = pytalloc_get_ptr(obj);
     422           0 :         PyObject *py_dwParam;
     423           0 :         py_dwParam = PyLong_FromUnsignedLongLong((uint32_t)(object->dwParam));
     424           0 :         return py_dwParam;
     425             : }
     426             : 
     427         799 : static int py_DNS_RPC_NAME_AND_PARAM_set_dwParam(PyObject *py_obj, PyObject *value, void *closure)
     428             : {
     429         799 :         struct DNS_RPC_NAME_AND_PARAM *object = pytalloc_get_ptr(py_obj);
     430         799 :         if (value == NULL) {
     431           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwParam");
     432           0 :                 return -1;
     433             :         }
     434             :         {
     435         799 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwParam));
     436         799 :                 if (PyLong_Check(value)) {
     437           0 :                         unsigned long long test_var;
     438         799 :                         test_var = PyLong_AsUnsignedLongLong(value);
     439         799 :                         if (PyErr_Occurred() != NULL) {
     440           0 :                                 return -1;
     441             :                         }
     442         799 :                         if (test_var > uint_max) {
     443           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
     444             :                                   PyLong_Type.tp_name, uint_max, test_var);
     445           0 :                                 return -1;
     446             :                         }
     447         799 :                         object->dwParam = test_var;
     448             :                 } else {
     449           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
     450             :                           PyLong_Type.tp_name);
     451           0 :                         return -1;
     452             :                 }
     453             :         }
     454         799 :         return 0;
     455             : }
     456             : 
     457           0 : static PyObject *py_DNS_RPC_NAME_AND_PARAM_get_pszNodeName(PyObject *obj, void *closure)
     458             : {
     459           0 :         struct DNS_RPC_NAME_AND_PARAM *object = pytalloc_get_ptr(obj);
     460           0 :         PyObject *py_pszNodeName;
     461           0 :         if (object->pszNodeName == NULL) {
     462           0 :                 Py_RETURN_NONE;
     463             :         }
     464           0 :         if (object->pszNodeName == NULL) {
     465           0 :                 py_pszNodeName = Py_None;
     466           0 :                 Py_INCREF(py_pszNodeName);
     467             :         } else {
     468           0 :                 if (object->pszNodeName == NULL) {
     469           0 :                         py_pszNodeName = Py_None;
     470           0 :                         Py_INCREF(py_pszNodeName);
     471             :                 } else {
     472           0 :                         py_pszNodeName = PyUnicode_Decode(object->pszNodeName, strlen(object->pszNodeName), "utf-8", "ignore");
     473             :                 }
     474             :         }
     475           0 :         return py_pszNodeName;
     476             : }
     477             : 
     478         799 : static int py_DNS_RPC_NAME_AND_PARAM_set_pszNodeName(PyObject *py_obj, PyObject *value, void *closure)
     479             : {
     480         799 :         struct DNS_RPC_NAME_AND_PARAM *object = pytalloc_get_ptr(py_obj);
     481         799 :         if (value == NULL) {
     482           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszNodeName");
     483           0 :                 return -1;
     484             :         }
     485         799 :         if (value == Py_None) {
     486           0 :                 object->pszNodeName = NULL;
     487             :         } else {
     488         799 :                 object->pszNodeName = NULL;
     489             :                 {
     490           0 :                         const char *test_str;
     491           0 :                         const char *talloc_str;
     492         799 :                         PyObject *unicode = NULL;
     493         799 :                         if (PyUnicode_Check(value)) {
     494         799 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
     495         799 :                                 if (unicode == NULL) {
     496           0 :                                         return -1;
     497             :                                 }
     498         799 :                                 test_str = PyBytes_AS_STRING(unicode);
     499           0 :                         } else if (PyBytes_Check(value)) {
     500           0 :                                 test_str = PyBytes_AS_STRING(value);
     501             :                         } else {
     502           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
     503           0 :                                 return -1;
     504             :                         }
     505         799 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
     506         799 :                         if (unicode != NULL) {
     507         441 :                                 Py_DECREF(unicode);
     508             :                         }
     509         799 :                         if (talloc_str == NULL) {
     510           0 :                                 PyErr_NoMemory();
     511           0 :                                 return -1;
     512             :                         }
     513         799 :                         object->pszNodeName = talloc_str;
     514             :                 }
     515             :         }
     516         799 :         return 0;
     517             : }
     518             : 
     519             : static PyGetSetDef py_DNS_RPC_NAME_AND_PARAM_getsetters[] = {
     520             :         {
     521             :                 .name = discard_const_p(char, "dwParam"),
     522             :                 .get = py_DNS_RPC_NAME_AND_PARAM_get_dwParam,
     523             :                 .set = py_DNS_RPC_NAME_AND_PARAM_set_dwParam,
     524             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
     525             :         },
     526             :         {
     527             :                 .name = discard_const_p(char, "pszNodeName"),
     528             :                 .get = py_DNS_RPC_NAME_AND_PARAM_get_pszNodeName,
     529             :                 .set = py_DNS_RPC_NAME_AND_PARAM_set_pszNodeName,
     530             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
     531             :         },
     532             :         { .name = NULL }
     533             : };
     534             : 
     535         799 : static PyObject *py_DNS_RPC_NAME_AND_PARAM_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     536             : {
     537         799 :         return pytalloc_new(struct DNS_RPC_NAME_AND_PARAM, type);
     538             : }
     539             : 
     540             : 
     541             : static PyTypeObject DNS_RPC_NAME_AND_PARAM_Type = {
     542             :         PyVarObject_HEAD_INIT(NULL, 0)
     543             :         .tp_name = "dnsserver.DNS_RPC_NAME_AND_PARAM",
     544             :         .tp_getset = py_DNS_RPC_NAME_AND_PARAM_getsetters,
     545             :         .tp_methods = NULL,
     546             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     547             :         .tp_new = py_DNS_RPC_NAME_AND_PARAM_new,
     548             : };
     549             : 
     550             : 
     551           0 : static PyObject *py_DNS_RPC_NAME_get_len(PyObject *obj, void *closure)
     552             : {
     553           0 :         struct DNS_RPC_NAME *object = pytalloc_get_ptr(obj);
     554           0 :         PyObject *py_len;
     555           0 :         py_len = PyLong_FromLong((uint16_t)(object->len));
     556           0 :         return py_len;
     557             : }
     558             : 
     559        2805 : static int py_DNS_RPC_NAME_set_len(PyObject *py_obj, PyObject *value, void *closure)
     560             : {
     561        2805 :         struct DNS_RPC_NAME *object = pytalloc_get_ptr(py_obj);
     562        2805 :         if (value == NULL) {
     563           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->len");
     564           0 :                 return -1;
     565             :         }
     566             :         {
     567        2805 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->len));
     568        2805 :                 if (PyLong_Check(value)) {
     569           0 :                         unsigned long long test_var;
     570        2805 :                         test_var = PyLong_AsUnsignedLongLong(value);
     571        2805 :                         if (PyErr_Occurred() != NULL) {
     572           0 :                                 return -1;
     573             :                         }
     574        2805 :                         if (test_var > uint_max) {
     575           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
     576             :                                   PyLong_Type.tp_name, uint_max, test_var);
     577           0 :                                 return -1;
     578             :                         }
     579        2805 :                         object->len = test_var;
     580             :                 } else {
     581           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
     582             :                           PyLong_Type.tp_name);
     583           0 :                         return -1;
     584             :                 }
     585             :         }
     586        2805 :         return 0;
     587             : }
     588             : 
     589         515 : static PyObject *py_DNS_RPC_NAME_get_str(PyObject *obj, void *closure)
     590             : {
     591         515 :         struct DNS_RPC_NAME *object = pytalloc_get_ptr(obj);
     592           0 :         PyObject *py_str;
     593         515 :         if (object->str == NULL) {
     594           0 :                 py_str = Py_None;
     595           0 :                 Py_INCREF(py_str);
     596             :         } else {
     597         515 :                 py_str = PyUnicode_Decode(object->str, strlen(object->str), "utf-8", "ignore");
     598             :         }
     599         515 :         return py_str;
     600             : }
     601             : 
     602        2805 : static int py_DNS_RPC_NAME_set_str(PyObject *py_obj, PyObject *value, void *closure)
     603             : {
     604        2805 :         struct DNS_RPC_NAME *object = pytalloc_get_ptr(py_obj);
     605        2805 :         if (value == NULL) {
     606           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->str");
     607           0 :                 return -1;
     608             :         }
     609             :         {
     610           0 :                 const char *test_str;
     611           0 :                 const char *talloc_str;
     612        2805 :                 PyObject *unicode = NULL;
     613        2805 :                 if (PyUnicode_Check(value)) {
     614        2805 :                         unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
     615        2805 :                         if (unicode == NULL) {
     616           0 :                                 return -1;
     617             :                         }
     618        2805 :                         test_str = PyBytes_AS_STRING(unicode);
     619           0 :                 } else if (PyBytes_Check(value)) {
     620           0 :                         test_str = PyBytes_AS_STRING(value);
     621             :                 } else {
     622           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
     623           0 :                         return -1;
     624             :                 }
     625        2805 :                 talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
     626        2805 :                 if (unicode != NULL) {
     627        2083 :                         Py_DECREF(unicode);
     628             :                 }
     629        2805 :                 if (talloc_str == NULL) {
     630           0 :                         PyErr_NoMemory();
     631           0 :                         return -1;
     632             :                 }
     633        2805 :                 object->str = talloc_str;
     634             :         }
     635        2805 :         return 0;
     636             : }
     637             : 
     638             : static PyGetSetDef py_DNS_RPC_NAME_getsetters[] = {
     639             :         {
     640             :                 .name = discard_const_p(char, "len"),
     641             :                 .get = py_DNS_RPC_NAME_get_len,
     642             :                 .set = py_DNS_RPC_NAME_set_len,
     643             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
     644             :         },
     645             :         {
     646             :                 .name = discard_const_p(char, "str"),
     647             :                 .get = py_DNS_RPC_NAME_get_str,
     648             :                 .set = py_DNS_RPC_NAME_set_str,
     649             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
     650             :         },
     651             :         { .name = NULL }
     652             : };
     653             : 
     654        1790 : static PyObject *py_DNS_RPC_NAME_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     655             : {
     656        1790 :         return pytalloc_new(struct DNS_RPC_NAME, type);
     657             : }
     658             : 
     659           0 : static PyObject *py_DNS_RPC_NAME_ndr_pack(PyObject *py_obj,  PyObject *Py_UNUSED(ignored))
     660             : {
     661           0 :         struct DNS_RPC_NAME *object = pytalloc_get_ptr(py_obj);
     662           0 :         PyObject *ret = NULL;
     663           0 :         DATA_BLOB blob;
     664           0 :         enum ndr_err_code err;
     665           0 :         TALLOC_CTX *tmp_ctx = talloc_new(pytalloc_get_mem_ctx(py_obj));
     666           0 :         if (tmp_ctx == NULL) {
     667           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
     668           0 :                 return NULL;
     669             :         }
     670           0 :         err = ndr_push_struct_blob(&blob, tmp_ctx, object, (ndr_push_flags_fn_t)ndr_push_DNS_RPC_NAME);
     671           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
     672           0 :                 TALLOC_FREE(tmp_ctx);
     673           0 :                 PyErr_SetNdrError(err);
     674           0 :                 return NULL;
     675             :         }
     676             : 
     677           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
     678           0 :         TALLOC_FREE(tmp_ctx);
     679           0 :         return ret;
     680             : }
     681             : 
     682           0 : static PyObject *py_DNS_RPC_NAME_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
     683             : {
     684           0 :         struct DNS_RPC_NAME *object = pytalloc_get_ptr(py_obj);
     685           0 :         DATA_BLOB blob = {.data = NULL, .length = 0};
     686           0 :         Py_ssize_t blob_length = 0;
     687           0 :         enum ndr_err_code err;
     688           0 :         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
     689           0 :         PyObject *allow_remaining_obj = NULL;
     690           0 :         bool allow_remaining = false;
     691             : 
     692           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|O:__ndr_unpack__",
     693             :                 discard_const_p(char *, kwnames),
     694             :                 &blob.data, &blob_length,
     695             :                 &allow_remaining_obj)) {
     696           0 :                 return NULL;
     697             :         }
     698           0 :         blob.length = blob_length;
     699             : 
     700           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
     701           0 :                 allow_remaining = true;
     702             :         }
     703             : 
     704           0 :         if (allow_remaining) {
     705           0 :                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_DNS_RPC_NAME);
     706             :         } else {
     707           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);
     708             :         }
     709           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
     710           0 :                 PyErr_SetNdrError(err);
     711           0 :                 return NULL;
     712             :         }
     713             : 
     714           0 :         Py_RETURN_NONE;
     715             : }
     716             : 
     717           0 : static PyObject *py_DNS_RPC_NAME_ndr_print(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
     718             : {
     719           0 :         struct DNS_RPC_NAME *object = pytalloc_get_ptr(py_obj);
     720           0 :         PyObject *ret;
     721           0 :         char *retstr;
     722             : 
     723           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);
     724           0 :         ret = PyUnicode_FromString(retstr);
     725           0 :         talloc_free(retstr);
     726             : 
     727           0 :         return ret;
     728             : }
     729             : 
     730             : static PyMethodDef py_DNS_RPC_NAME_methods[] = {
     731             :         { "__ndr_pack__", (PyCFunction)py_DNS_RPC_NAME_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
     732             :         { "__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" },
     733             :         { "__ndr_print__", (PyCFunction)py_DNS_RPC_NAME_ndr_print, METH_NOARGS, "S.ndr_print(object) -> None\nNDR print" },
     734             :         { NULL, NULL, 0, NULL }
     735             : };
     736             : 
     737             : 
     738             : static PyTypeObject DNS_RPC_NAME_Type = {
     739             :         PyVarObject_HEAD_INIT(NULL, 0)
     740             :         .tp_name = "dnsserver.DNS_RPC_NAME",
     741             :         .tp_getset = py_DNS_RPC_NAME_getsetters,
     742             :         .tp_methods = py_DNS_RPC_NAME_methods,
     743             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     744             :         .tp_new = py_DNS_RPC_NAME_new,
     745             : };
     746             : 
     747             : 
     748           0 : static PyObject *py_DNS_RPC_NODE_get_wLength(PyObject *obj, void *closure)
     749             : {
     750           0 :         struct DNS_RPC_NODE *object = pytalloc_get_ptr(obj);
     751           0 :         PyObject *py_wLength;
     752           0 :         py_wLength = PyLong_FromLong((uint16_t)(object->wLength));
     753           0 :         return py_wLength;
     754             : }
     755             : 
     756           0 : static int py_DNS_RPC_NODE_set_wLength(PyObject *py_obj, PyObject *value, void *closure)
     757             : {
     758           0 :         struct DNS_RPC_NODE *object = pytalloc_get_ptr(py_obj);
     759           0 :         if (value == NULL) {
     760           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->wLength");
     761           0 :                 return -1;
     762             :         }
     763             :         {
     764           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->wLength));
     765           0 :                 if (PyLong_Check(value)) {
     766           0 :                         unsigned long long test_var;
     767           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
     768           0 :                         if (PyErr_Occurred() != NULL) {
     769           0 :                                 return -1;
     770             :                         }
     771           0 :                         if (test_var > uint_max) {
     772           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
     773             :                                   PyLong_Type.tp_name, uint_max, test_var);
     774           0 :                                 return -1;
     775             :                         }
     776           0 :                         object->wLength = test_var;
     777             :                 } else {
     778           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
     779             :                           PyLong_Type.tp_name);
     780           0 :                         return -1;
     781             :                 }
     782             :         }
     783           0 :         return 0;
     784             : }
     785             : 
     786           0 : static PyObject *py_DNS_RPC_NODE_get_wRecordCount(PyObject *obj, void *closure)
     787             : {
     788           0 :         struct DNS_RPC_NODE *object = pytalloc_get_ptr(obj);
     789           0 :         PyObject *py_wRecordCount;
     790           0 :         py_wRecordCount = PyLong_FromLong((uint16_t)(object->wRecordCount));
     791           0 :         return py_wRecordCount;
     792             : }
     793             : 
     794           0 : static int py_DNS_RPC_NODE_set_wRecordCount(PyObject *py_obj, PyObject *value, void *closure)
     795             : {
     796           0 :         struct DNS_RPC_NODE *object = pytalloc_get_ptr(py_obj);
     797           0 :         if (value == NULL) {
     798           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->wRecordCount");
     799           0 :                 return -1;
     800             :         }
     801             :         {
     802           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->wRecordCount));
     803           0 :                 if (PyLong_Check(value)) {
     804           0 :                         unsigned long long test_var;
     805           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
     806           0 :                         if (PyErr_Occurred() != NULL) {
     807           0 :                                 return -1;
     808             :                         }
     809           0 :                         if (test_var > uint_max) {
     810           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
     811             :                                   PyLong_Type.tp_name, uint_max, test_var);
     812           0 :                                 return -1;
     813             :                         }
     814           0 :                         object->wRecordCount = test_var;
     815             :                 } else {
     816           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
     817             :                           PyLong_Type.tp_name);
     818           0 :                         return -1;
     819             :                 }
     820             :         }
     821           0 :         return 0;
     822             : }
     823             : 
     824           0 : static PyObject *py_DNS_RPC_NODE_get_dwFlags(PyObject *obj, void *closure)
     825             : {
     826           0 :         struct DNS_RPC_NODE *object = pytalloc_get_ptr(obj);
     827           0 :         PyObject *py_dwFlags;
     828           0 :         py_dwFlags = PyLong_FromUnsignedLongLong((uint32_t)(object->dwFlags));
     829           0 :         return py_dwFlags;
     830             : }
     831             : 
     832           0 : static int py_DNS_RPC_NODE_set_dwFlags(PyObject *py_obj, PyObject *value, void *closure)
     833             : {
     834           0 :         struct DNS_RPC_NODE *object = pytalloc_get_ptr(py_obj);
     835           0 :         if (value == NULL) {
     836           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwFlags");
     837           0 :                 return -1;
     838             :         }
     839             :         {
     840           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwFlags));
     841           0 :                 if (PyLong_Check(value)) {
     842           0 :                         unsigned long long test_var;
     843           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
     844           0 :                         if (PyErr_Occurred() != NULL) {
     845           0 :                                 return -1;
     846             :                         }
     847           0 :                         if (test_var > uint_max) {
     848           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
     849             :                                   PyLong_Type.tp_name, uint_max, test_var);
     850           0 :                                 return -1;
     851             :                         }
     852           0 :                         object->dwFlags = test_var;
     853             :                 } else {
     854           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
     855             :                           PyLong_Type.tp_name);
     856           0 :                         return -1;
     857             :                 }
     858             :         }
     859           0 :         return 0;
     860             : }
     861             : 
     862           0 : static PyObject *py_DNS_RPC_NODE_get_dwChildCount(PyObject *obj, void *closure)
     863             : {
     864           0 :         struct DNS_RPC_NODE *object = pytalloc_get_ptr(obj);
     865           0 :         PyObject *py_dwChildCount;
     866           0 :         py_dwChildCount = PyLong_FromUnsignedLongLong((uint32_t)(object->dwChildCount));
     867           0 :         return py_dwChildCount;
     868             : }
     869             : 
     870           0 : static int py_DNS_RPC_NODE_set_dwChildCount(PyObject *py_obj, PyObject *value, void *closure)
     871             : {
     872           0 :         struct DNS_RPC_NODE *object = pytalloc_get_ptr(py_obj);
     873           0 :         if (value == NULL) {
     874           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwChildCount");
     875           0 :                 return -1;
     876             :         }
     877             :         {
     878           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwChildCount));
     879           0 :                 if (PyLong_Check(value)) {
     880           0 :                         unsigned long long test_var;
     881           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
     882           0 :                         if (PyErr_Occurred() != NULL) {
     883           0 :                                 return -1;
     884             :                         }
     885           0 :                         if (test_var > uint_max) {
     886           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
     887             :                                   PyLong_Type.tp_name, uint_max, test_var);
     888           0 :                                 return -1;
     889             :                         }
     890           0 :                         object->dwChildCount = test_var;
     891             :                 } else {
     892           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
     893             :                           PyLong_Type.tp_name);
     894           0 :                         return -1;
     895             :                 }
     896             :         }
     897           0 :         return 0;
     898             : }
     899             : 
     900           0 : static PyObject *py_DNS_RPC_NODE_get_dnsNodeName(PyObject *obj, void *closure)
     901             : {
     902           0 :         struct DNS_RPC_NODE *object = pytalloc_get_ptr(obj);
     903           0 :         PyObject *py_dnsNodeName;
     904           0 :         py_dnsNodeName = pytalloc_reference_ex(&DNS_RPC_NAME_Type, pytalloc_get_mem_ctx(obj), &object->dnsNodeName);
     905           0 :         return py_dnsNodeName;
     906             : }
     907             : 
     908           0 : static int py_DNS_RPC_NODE_set_dnsNodeName(PyObject *py_obj, PyObject *value, void *closure)
     909             : {
     910           0 :         struct DNS_RPC_NODE *object = pytalloc_get_ptr(py_obj);
     911           0 :         if (value == NULL) {
     912           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dnsNodeName");
     913           0 :                 return -1;
     914             :         }
     915           0 :         PY_CHECK_TYPE(&DNS_RPC_NAME_Type, value, return -1;);
     916           0 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
     917           0 :                 PyErr_NoMemory();
     918           0 :                 return -1;
     919             :         }
     920           0 :         object->dnsNodeName = *(struct DNS_RPC_NAME *)pytalloc_get_ptr(value);
     921           0 :         return 0;
     922             : }
     923             : 
     924             : static PyGetSetDef py_DNS_RPC_NODE_getsetters[] = {
     925             :         {
     926             :                 .name = discard_const_p(char, "wLength"),
     927             :                 .get = py_DNS_RPC_NODE_get_wLength,
     928             :                 .set = py_DNS_RPC_NODE_set_wLength,
     929             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
     930             :         },
     931             :         {
     932             :                 .name = discard_const_p(char, "wRecordCount"),
     933             :                 .get = py_DNS_RPC_NODE_get_wRecordCount,
     934             :                 .set = py_DNS_RPC_NODE_set_wRecordCount,
     935             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
     936             :         },
     937             :         {
     938             :                 .name = discard_const_p(char, "dwFlags"),
     939             :                 .get = py_DNS_RPC_NODE_get_dwFlags,
     940             :                 .set = py_DNS_RPC_NODE_set_dwFlags,
     941             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
     942             :         },
     943             :         {
     944             :                 .name = discard_const_p(char, "dwChildCount"),
     945             :                 .get = py_DNS_RPC_NODE_get_dwChildCount,
     946             :                 .set = py_DNS_RPC_NODE_set_dwChildCount,
     947             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
     948             :         },
     949             :         {
     950             :                 .name = discard_const_p(char, "dnsNodeName"),
     951             :                 .get = py_DNS_RPC_NODE_get_dnsNodeName,
     952             :                 .set = py_DNS_RPC_NODE_set_dnsNodeName,
     953             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_NAME")
     954             :         },
     955             :         { .name = NULL }
     956             : };
     957             : 
     958           0 : static PyObject *py_DNS_RPC_NODE_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
     959             : {
     960           0 :         return pytalloc_new(struct DNS_RPC_NODE, type);
     961             : }
     962             : 
     963             : 
     964             : static PyTypeObject DNS_RPC_NODE_Type = {
     965             :         PyVarObject_HEAD_INIT(NULL, 0)
     966             :         .tp_name = "dnsserver.DNS_RPC_NODE",
     967             :         .tp_getset = py_DNS_RPC_NODE_getsetters,
     968             :         .tp_methods = NULL,
     969             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
     970             :         .tp_new = py_DNS_RPC_NODE_new,
     971             : };
     972             : 
     973             : 
     974           0 : static PyObject *py_DNS_RPC_RECORD_SOA_get_dwSerialNo(PyObject *obj, void *closure)
     975             : {
     976           0 :         struct DNS_RPC_RECORD_SOA *object = pytalloc_get_ptr(obj);
     977           0 :         PyObject *py_dwSerialNo;
     978           0 :         py_dwSerialNo = PyLong_FromUnsignedLongLong((uint32_t)(object->dwSerialNo));
     979           0 :         return py_dwSerialNo;
     980             : }
     981             : 
     982           0 : static int py_DNS_RPC_RECORD_SOA_set_dwSerialNo(PyObject *py_obj, PyObject *value, void *closure)
     983             : {
     984           0 :         struct DNS_RPC_RECORD_SOA *object = pytalloc_get_ptr(py_obj);
     985           0 :         if (value == NULL) {
     986           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwSerialNo");
     987           0 :                 return -1;
     988             :         }
     989             :         {
     990           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwSerialNo));
     991           0 :                 if (PyLong_Check(value)) {
     992           0 :                         unsigned long long test_var;
     993           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
     994           0 :                         if (PyErr_Occurred() != NULL) {
     995           0 :                                 return -1;
     996             :                         }
     997           0 :                         if (test_var > uint_max) {
     998           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
     999             :                                   PyLong_Type.tp_name, uint_max, test_var);
    1000           0 :                                 return -1;
    1001             :                         }
    1002           0 :                         object->dwSerialNo = test_var;
    1003             :                 } else {
    1004           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1005             :                           PyLong_Type.tp_name);
    1006           0 :                         return -1;
    1007             :                 }
    1008             :         }
    1009           0 :         return 0;
    1010             : }
    1011             : 
    1012           0 : static PyObject *py_DNS_RPC_RECORD_SOA_get_dwRefresh(PyObject *obj, void *closure)
    1013             : {
    1014           0 :         struct DNS_RPC_RECORD_SOA *object = pytalloc_get_ptr(obj);
    1015           0 :         PyObject *py_dwRefresh;
    1016           0 :         py_dwRefresh = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRefresh));
    1017           0 :         return py_dwRefresh;
    1018             : }
    1019             : 
    1020           0 : static int py_DNS_RPC_RECORD_SOA_set_dwRefresh(PyObject *py_obj, PyObject *value, void *closure)
    1021             : {
    1022           0 :         struct DNS_RPC_RECORD_SOA *object = pytalloc_get_ptr(py_obj);
    1023           0 :         if (value == NULL) {
    1024           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRefresh");
    1025           0 :                 return -1;
    1026             :         }
    1027             :         {
    1028           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRefresh));
    1029           0 :                 if (PyLong_Check(value)) {
    1030           0 :                         unsigned long long test_var;
    1031           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    1032           0 :                         if (PyErr_Occurred() != NULL) {
    1033           0 :                                 return -1;
    1034             :                         }
    1035           0 :                         if (test_var > uint_max) {
    1036           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    1037             :                                   PyLong_Type.tp_name, uint_max, test_var);
    1038           0 :                                 return -1;
    1039             :                         }
    1040           0 :                         object->dwRefresh = test_var;
    1041             :                 } else {
    1042           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1043             :                           PyLong_Type.tp_name);
    1044           0 :                         return -1;
    1045             :                 }
    1046             :         }
    1047           0 :         return 0;
    1048             : }
    1049             : 
    1050           0 : static PyObject *py_DNS_RPC_RECORD_SOA_get_dwRetry(PyObject *obj, void *closure)
    1051             : {
    1052           0 :         struct DNS_RPC_RECORD_SOA *object = pytalloc_get_ptr(obj);
    1053           0 :         PyObject *py_dwRetry;
    1054           0 :         py_dwRetry = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRetry));
    1055           0 :         return py_dwRetry;
    1056             : }
    1057             : 
    1058           0 : static int py_DNS_RPC_RECORD_SOA_set_dwRetry(PyObject *py_obj, PyObject *value, void *closure)
    1059             : {
    1060           0 :         struct DNS_RPC_RECORD_SOA *object = pytalloc_get_ptr(py_obj);
    1061           0 :         if (value == NULL) {
    1062           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRetry");
    1063           0 :                 return -1;
    1064             :         }
    1065             :         {
    1066           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRetry));
    1067           0 :                 if (PyLong_Check(value)) {
    1068           0 :                         unsigned long long test_var;
    1069           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    1070           0 :                         if (PyErr_Occurred() != NULL) {
    1071           0 :                                 return -1;
    1072             :                         }
    1073           0 :                         if (test_var > uint_max) {
    1074           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    1075             :                                   PyLong_Type.tp_name, uint_max, test_var);
    1076           0 :                                 return -1;
    1077             :                         }
    1078           0 :                         object->dwRetry = test_var;
    1079             :                 } else {
    1080           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1081             :                           PyLong_Type.tp_name);
    1082           0 :                         return -1;
    1083             :                 }
    1084             :         }
    1085           0 :         return 0;
    1086             : }
    1087             : 
    1088           0 : static PyObject *py_DNS_RPC_RECORD_SOA_get_dwExpire(PyObject *obj, void *closure)
    1089             : {
    1090           0 :         struct DNS_RPC_RECORD_SOA *object = pytalloc_get_ptr(obj);
    1091           0 :         PyObject *py_dwExpire;
    1092           0 :         py_dwExpire = PyLong_FromUnsignedLongLong((uint32_t)(object->dwExpire));
    1093           0 :         return py_dwExpire;
    1094             : }
    1095             : 
    1096           0 : static int py_DNS_RPC_RECORD_SOA_set_dwExpire(PyObject *py_obj, PyObject *value, void *closure)
    1097             : {
    1098           0 :         struct DNS_RPC_RECORD_SOA *object = pytalloc_get_ptr(py_obj);
    1099           0 :         if (value == NULL) {
    1100           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwExpire");
    1101           0 :                 return -1;
    1102             :         }
    1103             :         {
    1104           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwExpire));
    1105           0 :                 if (PyLong_Check(value)) {
    1106           0 :                         unsigned long long test_var;
    1107           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    1108           0 :                         if (PyErr_Occurred() != NULL) {
    1109           0 :                                 return -1;
    1110             :                         }
    1111           0 :                         if (test_var > uint_max) {
    1112           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    1113             :                                   PyLong_Type.tp_name, uint_max, test_var);
    1114           0 :                                 return -1;
    1115             :                         }
    1116           0 :                         object->dwExpire = test_var;
    1117             :                 } else {
    1118           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1119             :                           PyLong_Type.tp_name);
    1120           0 :                         return -1;
    1121             :                 }
    1122             :         }
    1123           0 :         return 0;
    1124             : }
    1125             : 
    1126           0 : static PyObject *py_DNS_RPC_RECORD_SOA_get_dwMinimumTtl(PyObject *obj, void *closure)
    1127             : {
    1128           0 :         struct DNS_RPC_RECORD_SOA *object = pytalloc_get_ptr(obj);
    1129           0 :         PyObject *py_dwMinimumTtl;
    1130           0 :         py_dwMinimumTtl = PyLong_FromUnsignedLongLong((uint32_t)(object->dwMinimumTtl));
    1131           0 :         return py_dwMinimumTtl;
    1132             : }
    1133             : 
    1134           0 : static int py_DNS_RPC_RECORD_SOA_set_dwMinimumTtl(PyObject *py_obj, PyObject *value, void *closure)
    1135             : {
    1136           0 :         struct DNS_RPC_RECORD_SOA *object = pytalloc_get_ptr(py_obj);
    1137           0 :         if (value == NULL) {
    1138           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwMinimumTtl");
    1139           0 :                 return -1;
    1140             :         }
    1141             :         {
    1142           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwMinimumTtl));
    1143           0 :                 if (PyLong_Check(value)) {
    1144           0 :                         unsigned long long test_var;
    1145           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    1146           0 :                         if (PyErr_Occurred() != NULL) {
    1147           0 :                                 return -1;
    1148             :                         }
    1149           0 :                         if (test_var > uint_max) {
    1150           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    1151             :                                   PyLong_Type.tp_name, uint_max, test_var);
    1152           0 :                                 return -1;
    1153             :                         }
    1154           0 :                         object->dwMinimumTtl = test_var;
    1155             :                 } else {
    1156           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1157             :                           PyLong_Type.tp_name);
    1158           0 :                         return -1;
    1159             :                 }
    1160             :         }
    1161           0 :         return 0;
    1162             : }
    1163             : 
    1164           0 : static PyObject *py_DNS_RPC_RECORD_SOA_get_NamePrimaryServer(PyObject *obj, void *closure)
    1165             : {
    1166           0 :         struct DNS_RPC_RECORD_SOA *object = pytalloc_get_ptr(obj);
    1167           0 :         PyObject *py_NamePrimaryServer;
    1168           0 :         py_NamePrimaryServer = pytalloc_reference_ex(&DNS_RPC_NAME_Type, pytalloc_get_mem_ctx(obj), &object->NamePrimaryServer);
    1169           0 :         return py_NamePrimaryServer;
    1170             : }
    1171             : 
    1172           0 : static int py_DNS_RPC_RECORD_SOA_set_NamePrimaryServer(PyObject *py_obj, PyObject *value, void *closure)
    1173             : {
    1174           0 :         struct DNS_RPC_RECORD_SOA *object = pytalloc_get_ptr(py_obj);
    1175           0 :         if (value == NULL) {
    1176           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->NamePrimaryServer");
    1177           0 :                 return -1;
    1178             :         }
    1179           0 :         PY_CHECK_TYPE(&DNS_RPC_NAME_Type, value, return -1;);
    1180           0 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    1181           0 :                 PyErr_NoMemory();
    1182           0 :                 return -1;
    1183             :         }
    1184           0 :         object->NamePrimaryServer = *(struct DNS_RPC_NAME *)pytalloc_get_ptr(value);
    1185           0 :         return 0;
    1186             : }
    1187             : 
    1188           0 : static PyObject *py_DNS_RPC_RECORD_SOA_get_ZoneAdministratorEmail(PyObject *obj, void *closure)
    1189             : {
    1190           0 :         struct DNS_RPC_RECORD_SOA *object = pytalloc_get_ptr(obj);
    1191           0 :         PyObject *py_ZoneAdministratorEmail;
    1192           0 :         py_ZoneAdministratorEmail = pytalloc_reference_ex(&DNS_RPC_NAME_Type, pytalloc_get_mem_ctx(obj), &object->ZoneAdministratorEmail);
    1193           0 :         return py_ZoneAdministratorEmail;
    1194             : }
    1195             : 
    1196           0 : static int py_DNS_RPC_RECORD_SOA_set_ZoneAdministratorEmail(PyObject *py_obj, PyObject *value, void *closure)
    1197             : {
    1198           0 :         struct DNS_RPC_RECORD_SOA *object = pytalloc_get_ptr(py_obj);
    1199           0 :         if (value == NULL) {
    1200           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->ZoneAdministratorEmail");
    1201           0 :                 return -1;
    1202             :         }
    1203           0 :         PY_CHECK_TYPE(&DNS_RPC_NAME_Type, value, return -1;);
    1204           0 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    1205           0 :                 PyErr_NoMemory();
    1206           0 :                 return -1;
    1207             :         }
    1208           0 :         object->ZoneAdministratorEmail = *(struct DNS_RPC_NAME *)pytalloc_get_ptr(value);
    1209           0 :         return 0;
    1210             : }
    1211             : 
    1212             : static PyGetSetDef py_DNS_RPC_RECORD_SOA_getsetters[] = {
    1213             :         {
    1214             :                 .name = discard_const_p(char, "dwSerialNo"),
    1215             :                 .get = py_DNS_RPC_RECORD_SOA_get_dwSerialNo,
    1216             :                 .set = py_DNS_RPC_RECORD_SOA_set_dwSerialNo,
    1217             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    1218             :         },
    1219             :         {
    1220             :                 .name = discard_const_p(char, "dwRefresh"),
    1221             :                 .get = py_DNS_RPC_RECORD_SOA_get_dwRefresh,
    1222             :                 .set = py_DNS_RPC_RECORD_SOA_set_dwRefresh,
    1223             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    1224             :         },
    1225             :         {
    1226             :                 .name = discard_const_p(char, "dwRetry"),
    1227             :                 .get = py_DNS_RPC_RECORD_SOA_get_dwRetry,
    1228             :                 .set = py_DNS_RPC_RECORD_SOA_set_dwRetry,
    1229             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    1230             :         },
    1231             :         {
    1232             :                 .name = discard_const_p(char, "dwExpire"),
    1233             :                 .get = py_DNS_RPC_RECORD_SOA_get_dwExpire,
    1234             :                 .set = py_DNS_RPC_RECORD_SOA_set_dwExpire,
    1235             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    1236             :         },
    1237             :         {
    1238             :                 .name = discard_const_p(char, "dwMinimumTtl"),
    1239             :                 .get = py_DNS_RPC_RECORD_SOA_get_dwMinimumTtl,
    1240             :                 .set = py_DNS_RPC_RECORD_SOA_set_dwMinimumTtl,
    1241             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    1242             :         },
    1243             :         {
    1244             :                 .name = discard_const_p(char, "NamePrimaryServer"),
    1245             :                 .get = py_DNS_RPC_RECORD_SOA_get_NamePrimaryServer,
    1246             :                 .set = py_DNS_RPC_RECORD_SOA_set_NamePrimaryServer,
    1247             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_NAME")
    1248             :         },
    1249             :         {
    1250             :                 .name = discard_const_p(char, "ZoneAdministratorEmail"),
    1251             :                 .get = py_DNS_RPC_RECORD_SOA_get_ZoneAdministratorEmail,
    1252             :                 .set = py_DNS_RPC_RECORD_SOA_set_ZoneAdministratorEmail,
    1253             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_NAME")
    1254             :         },
    1255             :         { .name = NULL }
    1256             : };
    1257             : 
    1258           0 : static PyObject *py_DNS_RPC_RECORD_SOA_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    1259             : {
    1260           0 :         return pytalloc_new(struct DNS_RPC_RECORD_SOA, type);
    1261             : }
    1262             : 
    1263             : 
    1264             : static PyTypeObject DNS_RPC_RECORD_SOA_Type = {
    1265             :         PyVarObject_HEAD_INIT(NULL, 0)
    1266             :         .tp_name = "dnsserver.DNS_RPC_RECORD_SOA",
    1267             :         .tp_getset = py_DNS_RPC_RECORD_SOA_getsetters,
    1268             :         .tp_methods = NULL,
    1269             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    1270             :         .tp_new = py_DNS_RPC_RECORD_SOA_new,
    1271             : };
    1272             : 
    1273             : 
    1274          43 : static PyObject *py_DNS_RPC_RECORD_NAME_PREFERENCE_get_wPreference(PyObject *obj, void *closure)
    1275             : {
    1276          43 :         struct DNS_RPC_RECORD_NAME_PREFERENCE *object = pytalloc_get_ptr(obj);
    1277           0 :         PyObject *py_wPreference;
    1278          43 :         py_wPreference = PyLong_FromLong((uint16_t)(object->wPreference));
    1279          43 :         return py_wPreference;
    1280             : }
    1281             : 
    1282         436 : static int py_DNS_RPC_RECORD_NAME_PREFERENCE_set_wPreference(PyObject *py_obj, PyObject *value, void *closure)
    1283             : {
    1284         436 :         struct DNS_RPC_RECORD_NAME_PREFERENCE *object = pytalloc_get_ptr(py_obj);
    1285         436 :         if (value == NULL) {
    1286           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->wPreference");
    1287           0 :                 return -1;
    1288             :         }
    1289             :         {
    1290         436 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->wPreference));
    1291         436 :                 if (PyLong_Check(value)) {
    1292           0 :                         unsigned long long test_var;
    1293         436 :                         test_var = PyLong_AsUnsignedLongLong(value);
    1294         436 :                         if (PyErr_Occurred() != NULL) {
    1295           3 :                                 return -1;
    1296             :                         }
    1297         433 :                         if (test_var > uint_max) {
    1298           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    1299             :                                   PyLong_Type.tp_name, uint_max, test_var);
    1300           0 :                                 return -1;
    1301             :                         }
    1302         433 :                         object->wPreference = test_var;
    1303             :                 } else {
    1304           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1305             :                           PyLong_Type.tp_name);
    1306           0 :                         return -1;
    1307             :                 }
    1308             :         }
    1309         433 :         return 0;
    1310             : }
    1311             : 
    1312         909 : static PyObject *py_DNS_RPC_RECORD_NAME_PREFERENCE_get_nameExchange(PyObject *obj, void *closure)
    1313             : {
    1314         909 :         struct DNS_RPC_RECORD_NAME_PREFERENCE *object = pytalloc_get_ptr(obj);
    1315           0 :         PyObject *py_nameExchange;
    1316         909 :         py_nameExchange = pytalloc_reference_ex(&DNS_RPC_NAME_Type, pytalloc_get_mem_ctx(obj), &object->nameExchange);
    1317         909 :         return py_nameExchange;
    1318             : }
    1319             : 
    1320           0 : static int py_DNS_RPC_RECORD_NAME_PREFERENCE_set_nameExchange(PyObject *py_obj, PyObject *value, void *closure)
    1321             : {
    1322           0 :         struct DNS_RPC_RECORD_NAME_PREFERENCE *object = pytalloc_get_ptr(py_obj);
    1323           0 :         if (value == NULL) {
    1324           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->nameExchange");
    1325           0 :                 return -1;
    1326             :         }
    1327           0 :         PY_CHECK_TYPE(&DNS_RPC_NAME_Type, value, return -1;);
    1328           0 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    1329           0 :                 PyErr_NoMemory();
    1330           0 :                 return -1;
    1331             :         }
    1332           0 :         object->nameExchange = *(struct DNS_RPC_NAME *)pytalloc_get_ptr(value);
    1333           0 :         return 0;
    1334             : }
    1335             : 
    1336             : static PyGetSetDef py_DNS_RPC_RECORD_NAME_PREFERENCE_getsetters[] = {
    1337             :         {
    1338             :                 .name = discard_const_p(char, "wPreference"),
    1339             :                 .get = py_DNS_RPC_RECORD_NAME_PREFERENCE_get_wPreference,
    1340             :                 .set = py_DNS_RPC_RECORD_NAME_PREFERENCE_set_wPreference,
    1341             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
    1342             :         },
    1343             :         {
    1344             :                 .name = discard_const_p(char, "nameExchange"),
    1345             :                 .get = py_DNS_RPC_RECORD_NAME_PREFERENCE_get_nameExchange,
    1346             :                 .set = py_DNS_RPC_RECORD_NAME_PREFERENCE_set_nameExchange,
    1347             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_NAME")
    1348             :         },
    1349             :         { .name = NULL }
    1350             : };
    1351             : 
    1352         436 : static PyObject *py_DNS_RPC_RECORD_NAME_PREFERENCE_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    1353             : {
    1354         436 :         return pytalloc_new(struct DNS_RPC_RECORD_NAME_PREFERENCE, type);
    1355             : }
    1356             : 
    1357             : 
    1358             : static PyTypeObject DNS_RPC_RECORD_NAME_PREFERENCE_Type = {
    1359             :         PyVarObject_HEAD_INIT(NULL, 0)
    1360             :         .tp_name = "dnsserver.DNS_RPC_RECORD_NAME_PREFERENCE",
    1361             :         .tp_getset = py_DNS_RPC_RECORD_NAME_PREFERENCE_getsetters,
    1362             :         .tp_methods = NULL,
    1363             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    1364             :         .tp_new = py_DNS_RPC_RECORD_NAME_PREFERENCE_new,
    1365             : };
    1366             : 
    1367             : 
    1368          68 : static PyObject *py_DNS_RPC_RECORD_STRING_get_count(PyObject *obj, void *closure)
    1369             : {
    1370          68 :         struct DNS_RPC_RECORD_STRING *object = pytalloc_get_ptr(obj);
    1371           0 :         PyObject *py_count;
    1372          68 :         py_count = PyLong_FromLong((uint16_t)(object->count));
    1373          68 :         return py_count;
    1374             : }
    1375             : 
    1376         371 : static int py_DNS_RPC_RECORD_STRING_set_count(PyObject *py_obj, PyObject *value, void *closure)
    1377             : {
    1378         371 :         struct DNS_RPC_RECORD_STRING *object = pytalloc_get_ptr(py_obj);
    1379         371 :         if (value == NULL) {
    1380           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->count");
    1381           0 :                 return -1;
    1382             :         }
    1383             :         {
    1384         371 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->count));
    1385         371 :                 if (PyLong_Check(value)) {
    1386           0 :                         unsigned long long test_var;
    1387         371 :                         test_var = PyLong_AsUnsignedLongLong(value);
    1388         371 :                         if (PyErr_Occurred() != NULL) {
    1389           0 :                                 return -1;
    1390             :                         }
    1391         371 :                         if (test_var > uint_max) {
    1392           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    1393             :                                   PyLong_Type.tp_name, uint_max, test_var);
    1394           0 :                                 return -1;
    1395             :                         }
    1396         371 :                         object->count = test_var;
    1397             :                 } else {
    1398           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1399             :                           PyLong_Type.tp_name);
    1400           0 :                         return -1;
    1401             :                 }
    1402             :         }
    1403         371 :         return 0;
    1404             : }
    1405             : 
    1406          89 : static PyObject *py_DNS_RPC_RECORD_STRING_get_str(PyObject *obj, void *closure)
    1407             : {
    1408          89 :         struct DNS_RPC_RECORD_STRING *object = pytalloc_get_ptr(obj);
    1409           0 :         PyObject *py_str;
    1410          89 :         py_str = PyList_New(object->count);
    1411          89 :         if (py_str == NULL) {
    1412           0 :                 return NULL;
    1413             :         }
    1414             :         {
    1415             :                 int str_cntr_0;
    1416         288 :                 for (str_cntr_0 = 0; str_cntr_0 < (object->count); str_cntr_0++) {
    1417           0 :                         PyObject *py_str_0;
    1418         199 :                         py_str_0 = pytalloc_reference_ex(&DNS_RPC_NAME_Type, object->str, &(object->str)[str_cntr_0]);
    1419         199 :                         PyList_SetItem(py_str, str_cntr_0, py_str_0);
    1420             :                 }
    1421             :         }
    1422          89 :         return py_str;
    1423             : }
    1424             : 
    1425         371 : static int py_DNS_RPC_RECORD_STRING_set_str(PyObject *py_obj, PyObject *value, void *closure)
    1426             : {
    1427         371 :         struct DNS_RPC_RECORD_STRING *object = pytalloc_get_ptr(py_obj);
    1428         371 :         if (value == NULL) {
    1429           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->str");
    1430           0 :                 return -1;
    1431             :         }
    1432         371 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
    1433             :         {
    1434           0 :                 int str_cntr_0;
    1435         371 :                 object->str = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->str, PyList_GET_SIZE(value));
    1436         371 :                 if (!object->str) { return -1; }
    1437         371 :                 talloc_set_name_const(object->str, "ARRAY: object->str");
    1438         765 :                 for (str_cntr_0 = 0; str_cntr_0 < PyList_GET_SIZE(value); str_cntr_0++) {
    1439         394 :                         if (PyList_GET_ITEM(value, str_cntr_0) == NULL) {
    1440           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->str)[str_cntr_0]");
    1441           0 :                                 return -1;
    1442             :                         }
    1443         394 :                         PY_CHECK_TYPE(&DNS_RPC_NAME_Type, PyList_GET_ITEM(value, str_cntr_0), return -1;);
    1444         394 :                         if (talloc_reference(object->str, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, str_cntr_0))) == NULL) {
    1445           0 :                                 PyErr_NoMemory();
    1446           0 :                                 return -1;
    1447             :                         }
    1448         394 :                         (object->str)[str_cntr_0] = *(struct DNS_RPC_NAME *)pytalloc_get_ptr(PyList_GET_ITEM(value, str_cntr_0));
    1449             :                 }
    1450             :         }
    1451         371 :         return 0;
    1452             : }
    1453             : 
    1454             : static PyGetSetDef py_DNS_RPC_RECORD_STRING_getsetters[] = {
    1455             :         {
    1456             :                 .name = discard_const_p(char, "count"),
    1457             :                 .get = py_DNS_RPC_RECORD_STRING_get_count,
    1458             :                 .set = py_DNS_RPC_RECORD_STRING_set_count,
    1459             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    1460             :         },
    1461             :         {
    1462             :                 .name = discard_const_p(char, "str"),
    1463             :                 .get = py_DNS_RPC_RECORD_STRING_get_str,
    1464             :                 .set = py_DNS_RPC_RECORD_STRING_set_str,
    1465             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_NAME")
    1466             :         },
    1467             :         { .name = NULL }
    1468             : };
    1469             : 
    1470         371 : static PyObject *py_DNS_RPC_RECORD_STRING_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    1471             : {
    1472         371 :         return pytalloc_new(struct DNS_RPC_RECORD_STRING, type);
    1473             : }
    1474             : 
    1475             : 
    1476             : static PyTypeObject DNS_RPC_RECORD_STRING_Type = {
    1477             :         PyVarObject_HEAD_INIT(NULL, 0)
    1478             :         .tp_name = "dnsserver.DNS_RPC_RECORD_STRING",
    1479             :         .tp_getset = py_DNS_RPC_RECORD_STRING_getsetters,
    1480             :         .tp_methods = NULL,
    1481             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    1482             :         .tp_new = py_DNS_RPC_RECORD_STRING_new,
    1483             : };
    1484             : 
    1485             : 
    1486          85 : static PyObject *py_DNS_RPC_RECORD_SRV_get_wPriority(PyObject *obj, void *closure)
    1487             : {
    1488          85 :         struct DNS_RPC_RECORD_SRV *object = pytalloc_get_ptr(obj);
    1489           0 :         PyObject *py_wPriority;
    1490          85 :         py_wPriority = PyLong_FromLong((uint16_t)(object->wPriority));
    1491          85 :         return py_wPriority;
    1492             : }
    1493             : 
    1494         591 : static int py_DNS_RPC_RECORD_SRV_set_wPriority(PyObject *py_obj, PyObject *value, void *closure)
    1495             : {
    1496         591 :         struct DNS_RPC_RECORD_SRV *object = pytalloc_get_ptr(py_obj);
    1497         591 :         if (value == NULL) {
    1498           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->wPriority");
    1499           0 :                 return -1;
    1500             :         }
    1501             :         {
    1502         591 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->wPriority));
    1503         591 :                 if (PyLong_Check(value)) {
    1504           0 :                         unsigned long long test_var;
    1505         591 :                         test_var = PyLong_AsUnsignedLongLong(value);
    1506         591 :                         if (PyErr_Occurred() != NULL) {
    1507           0 :                                 return -1;
    1508             :                         }
    1509         591 :                         if (test_var > uint_max) {
    1510           3 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    1511             :                                   PyLong_Type.tp_name, uint_max, test_var);
    1512           3 :                                 return -1;
    1513             :                         }
    1514         588 :                         object->wPriority = test_var;
    1515             :                 } else {
    1516           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1517             :                           PyLong_Type.tp_name);
    1518           0 :                         return -1;
    1519             :                 }
    1520             :         }
    1521         588 :         return 0;
    1522             : }
    1523             : 
    1524          83 : static PyObject *py_DNS_RPC_RECORD_SRV_get_wWeight(PyObject *obj, void *closure)
    1525             : {
    1526          83 :         struct DNS_RPC_RECORD_SRV *object = pytalloc_get_ptr(obj);
    1527           0 :         PyObject *py_wWeight;
    1528          83 :         py_wWeight = PyLong_FromLong((uint16_t)(object->wWeight));
    1529          83 :         return py_wWeight;
    1530             : }
    1531             : 
    1532         588 : static int py_DNS_RPC_RECORD_SRV_set_wWeight(PyObject *py_obj, PyObject *value, void *closure)
    1533             : {
    1534         588 :         struct DNS_RPC_RECORD_SRV *object = pytalloc_get_ptr(py_obj);
    1535         588 :         if (value == NULL) {
    1536           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->wWeight");
    1537           0 :                 return -1;
    1538             :         }
    1539             :         {
    1540         588 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->wWeight));
    1541         588 :                 if (PyLong_Check(value)) {
    1542           0 :                         unsigned long long test_var;
    1543         588 :                         test_var = PyLong_AsUnsignedLongLong(value);
    1544         588 :                         if (PyErr_Occurred() != NULL) {
    1545           0 :                                 return -1;
    1546             :                         }
    1547         588 :                         if (test_var > uint_max) {
    1548           3 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    1549             :                                   PyLong_Type.tp_name, uint_max, test_var);
    1550           3 :                                 return -1;
    1551             :                         }
    1552         585 :                         object->wWeight = test_var;
    1553             :                 } else {
    1554           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1555             :                           PyLong_Type.tp_name);
    1556           0 :                         return -1;
    1557             :                 }
    1558             :         }
    1559         585 :         return 0;
    1560             : }
    1561             : 
    1562          83 : static PyObject *py_DNS_RPC_RECORD_SRV_get_wPort(PyObject *obj, void *closure)
    1563             : {
    1564          83 :         struct DNS_RPC_RECORD_SRV *object = pytalloc_get_ptr(obj);
    1565           0 :         PyObject *py_wPort;
    1566          83 :         py_wPort = PyLong_FromLong((uint16_t)(object->wPort));
    1567          83 :         return py_wPort;
    1568             : }
    1569             : 
    1570         585 : static int py_DNS_RPC_RECORD_SRV_set_wPort(PyObject *py_obj, PyObject *value, void *closure)
    1571             : {
    1572         585 :         struct DNS_RPC_RECORD_SRV *object = pytalloc_get_ptr(py_obj);
    1573         585 :         if (value == NULL) {
    1574           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->wPort");
    1575           0 :                 return -1;
    1576             :         }
    1577             :         {
    1578         585 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->wPort));
    1579         585 :                 if (PyLong_Check(value)) {
    1580           0 :                         unsigned long long test_var;
    1581         585 :                         test_var = PyLong_AsUnsignedLongLong(value);
    1582         585 :                         if (PyErr_Occurred() != NULL) {
    1583           0 :                                 return -1;
    1584             :                         }
    1585         585 :                         if (test_var > uint_max) {
    1586           3 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    1587             :                                   PyLong_Type.tp_name, uint_max, test_var);
    1588           3 :                                 return -1;
    1589             :                         }
    1590         582 :                         object->wPort = test_var;
    1591             :                 } else {
    1592           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1593             :                           PyLong_Type.tp_name);
    1594           0 :                         return -1;
    1595             :                 }
    1596             :         }
    1597         582 :         return 0;
    1598             : }
    1599             : 
    1600        1247 : static PyObject *py_DNS_RPC_RECORD_SRV_get_nameTarget(PyObject *obj, void *closure)
    1601             : {
    1602        1247 :         struct DNS_RPC_RECORD_SRV *object = pytalloc_get_ptr(obj);
    1603           0 :         PyObject *py_nameTarget;
    1604        1247 :         py_nameTarget = pytalloc_reference_ex(&DNS_RPC_NAME_Type, pytalloc_get_mem_ctx(obj), &object->nameTarget);
    1605        1247 :         return py_nameTarget;
    1606             : }
    1607             : 
    1608           0 : static int py_DNS_RPC_RECORD_SRV_set_nameTarget(PyObject *py_obj, PyObject *value, void *closure)
    1609             : {
    1610           0 :         struct DNS_RPC_RECORD_SRV *object = pytalloc_get_ptr(py_obj);
    1611           0 :         if (value == NULL) {
    1612           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->nameTarget");
    1613           0 :                 return -1;
    1614             :         }
    1615           0 :         PY_CHECK_TYPE(&DNS_RPC_NAME_Type, value, return -1;);
    1616           0 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    1617           0 :                 PyErr_NoMemory();
    1618           0 :                 return -1;
    1619             :         }
    1620           0 :         object->nameTarget = *(struct DNS_RPC_NAME *)pytalloc_get_ptr(value);
    1621           0 :         return 0;
    1622             : }
    1623             : 
    1624             : static PyGetSetDef py_DNS_RPC_RECORD_SRV_getsetters[] = {
    1625             :         {
    1626             :                 .name = discard_const_p(char, "wPriority"),
    1627             :                 .get = py_DNS_RPC_RECORD_SRV_get_wPriority,
    1628             :                 .set = py_DNS_RPC_RECORD_SRV_set_wPriority,
    1629             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
    1630             :         },
    1631             :         {
    1632             :                 .name = discard_const_p(char, "wWeight"),
    1633             :                 .get = py_DNS_RPC_RECORD_SRV_get_wWeight,
    1634             :                 .set = py_DNS_RPC_RECORD_SRV_set_wWeight,
    1635             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
    1636             :         },
    1637             :         {
    1638             :                 .name = discard_const_p(char, "wPort"),
    1639             :                 .get = py_DNS_RPC_RECORD_SRV_get_wPort,
    1640             :                 .set = py_DNS_RPC_RECORD_SRV_set_wPort,
    1641             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
    1642             :         },
    1643             :         {
    1644             :                 .name = discard_const_p(char, "nameTarget"),
    1645             :                 .get = py_DNS_RPC_RECORD_SRV_get_nameTarget,
    1646             :                 .set = py_DNS_RPC_RECORD_SRV_set_nameTarget,
    1647             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_NAME")
    1648             :         },
    1649             :         { .name = NULL }
    1650             : };
    1651             : 
    1652         591 : static PyObject *py_DNS_RPC_RECORD_SRV_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    1653             : {
    1654         591 :         return pytalloc_new(struct DNS_RPC_RECORD_SRV, type);
    1655             : }
    1656             : 
    1657             : 
    1658             : static PyTypeObject DNS_RPC_RECORD_SRV_Type = {
    1659             :         PyVarObject_HEAD_INIT(NULL, 0)
    1660             :         .tp_name = "dnsserver.DNS_RPC_RECORD_SRV",
    1661             :         .tp_getset = py_DNS_RPC_RECORD_SRV_getsetters,
    1662             :         .tp_methods = NULL,
    1663             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    1664             :         .tp_new = py_DNS_RPC_RECORD_SRV_new,
    1665             : };
    1666             : 
    1667         766 : static PyObject *py_import_DNS_RPC_RECORD_DATA(TALLOC_CTX *mem_ctx, int level, union DNS_RPC_RECORD_DATA *in)
    1668             : {
    1669           0 :         PyObject *ret;
    1670             : 
    1671         766 :         switch (level) {
    1672           0 :                 case DNS_TYPE_TOMBSTONE:
    1673           0 :                         ret = PyLong_FromUnsignedLongLong(in->EntombedTime);
    1674           0 :                         return ret;
    1675             : 
    1676          29 :                 case DNS_TYPE_A:
    1677          29 :                         ret = PyString_FromStringOrNULL(in->ipv4);
    1678          29 :                         return ret;
    1679             : 
    1680          39 :                 case DNS_TYPE_NS:
    1681          39 :                         ret = pytalloc_reference_ex(&DNS_RPC_NAME_Type, mem_ctx, &in->name);
    1682          39 :                         return ret;
    1683             : 
    1684           0 :                 case DNS_TYPE_MD:
    1685           0 :                         ret = pytalloc_reference_ex(&DNS_RPC_NAME_Type, mem_ctx, &in->name);
    1686           0 :                         return ret;
    1687             : 
    1688           0 :                 case DNS_TYPE_MF:
    1689           0 :                         ret = pytalloc_reference_ex(&DNS_RPC_NAME_Type, mem_ctx, &in->name);
    1690           0 :                         return ret;
    1691             : 
    1692          45 :                 case DNS_TYPE_CNAME:
    1693          45 :                         ret = pytalloc_reference_ex(&DNS_RPC_NAME_Type, mem_ctx, &in->name);
    1694          45 :                         return ret;
    1695             : 
    1696           0 :                 case DNS_TYPE_SOA:
    1697           0 :                         ret = pytalloc_reference_ex(&DNS_RPC_RECORD_SOA_Type, mem_ctx, &in->soa);
    1698           0 :                         return ret;
    1699             : 
    1700           0 :                 case DNS_TYPE_MB:
    1701           0 :                         ret = pytalloc_reference_ex(&DNS_RPC_NAME_Type, mem_ctx, &in->name);
    1702           0 :                         return ret;
    1703             : 
    1704           0 :                 case DNS_TYPE_MG:
    1705           0 :                         ret = pytalloc_reference_ex(&DNS_RPC_NAME_Type, mem_ctx, &in->name);
    1706           0 :                         return ret;
    1707             : 
    1708           0 :                 case DNS_TYPE_MR:
    1709           0 :                         ret = pytalloc_reference_ex(&DNS_RPC_NAME_Type, mem_ctx, &in->name);
    1710           0 :                         return ret;
    1711             : 
    1712          39 :                 case DNS_TYPE_PTR:
    1713          39 :                         ret = pytalloc_reference_ex(&DNS_RPC_NAME_Type, mem_ctx, &in->ptr);
    1714          39 :                         return ret;
    1715             : 
    1716           0 :                 case DNS_TYPE_HINFO:
    1717           0 :                         ret = pytalloc_reference_ex(&DNS_RPC_NAME_Type, mem_ctx, &in->hinfo);
    1718           0 :                         return ret;
    1719             : 
    1720          86 :                 case DNS_TYPE_MX:
    1721          86 :                         ret = pytalloc_reference_ex(&DNS_RPC_RECORD_NAME_PREFERENCE_Type, mem_ctx, &in->mx);
    1722          86 :                         return ret;
    1723             : 
    1724         157 :                 case DNS_TYPE_TXT:
    1725         157 :                         ret = pytalloc_reference_ex(&DNS_RPC_RECORD_STRING_Type, mem_ctx, &in->txt);
    1726         157 :                         return ret;
    1727             : 
    1728          37 :                 case DNS_TYPE_AAAA:
    1729          37 :                         ret = PyString_FromStringOrNULL(in->ipv6);
    1730          37 :                         return ret;
    1731             : 
    1732         334 :                 case DNS_TYPE_SRV:
    1733         334 :                         ret = pytalloc_reference_ex(&DNS_RPC_RECORD_SRV_Type, mem_ctx, &in->srv);
    1734         334 :                         return ret;
    1735             : 
    1736           0 :                 case DNS_TYPE_DNAME:
    1737           0 :                         ret = pytalloc_reference_ex(&DNS_RPC_NAME_Type, mem_ctx, &in->name);
    1738           0 :                         return ret;
    1739             : 
    1740             :         }
    1741           0 :         PyErr_SetString(PyExc_TypeError, "unknown union level");
    1742           0 :         return NULL;
    1743             : }
    1744             : 
    1745        4215 : static union DNS_RPC_RECORD_DATA *py_export_DNS_RPC_RECORD_DATA(TALLOC_CTX *mem_ctx, int level, PyObject *in)
    1746             : {
    1747        4215 :         union DNS_RPC_RECORD_DATA *ret = talloc_zero(mem_ctx, union DNS_RPC_RECORD_DATA);
    1748        4215 :         switch (level) {
    1749           0 :                 case DNS_TYPE_TOMBSTONE:
    1750           0 :                         if (in == NULL) {
    1751           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->EntombedTime");
    1752           0 :                                 talloc_free(ret); return NULL;
    1753             :                         }
    1754             :                         {
    1755           0 :                                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(ret->EntombedTime));
    1756           0 :                                 if (PyLong_Check(in)) {
    1757           0 :                                         unsigned long long test_var;
    1758           0 :                                         test_var = PyLong_AsUnsignedLongLong(in);
    1759           0 :                                         if (PyErr_Occurred() != NULL) {
    1760           0 :                                                 talloc_free(ret); return NULL;
    1761             :                                         }
    1762           0 :                                         if (test_var > uint_max) {
    1763           0 :                                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    1764             :                                                   PyLong_Type.tp_name, uint_max, test_var);
    1765           0 :                                                 talloc_free(ret); return NULL;
    1766             :                                         }
    1767           0 :                                         ret->EntombedTime = test_var;
    1768             :                                 } else {
    1769           0 :                                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    1770             :                                           PyLong_Type.tp_name);
    1771           0 :                                         talloc_free(ret); return NULL;
    1772             :                                 }
    1773             :                         }
    1774           0 :                         break;
    1775             : 
    1776         673 :                 case DNS_TYPE_A:
    1777         673 :                         if (in == NULL) {
    1778           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->ipv4");
    1779           0 :                                 talloc_free(ret); return NULL;
    1780             :                         }
    1781             :                         {
    1782           0 :                                 const char *test_str;
    1783           0 :                                 const char *talloc_str;
    1784         673 :                                 PyObject *unicode = NULL;
    1785         673 :                                 if (PyUnicode_Check(in)) {
    1786         673 :                                         unicode = PyUnicode_AsEncodedString(in, "utf-8", "ignore");
    1787         673 :                                         if (unicode == NULL) {
    1788           0 :                                                 talloc_free(ret); return NULL;
    1789             :                                         }
    1790         673 :                                         test_str = PyBytes_AS_STRING(unicode);
    1791           0 :                                 } else if (PyBytes_Check(in)) {
    1792           0 :                                         test_str = PyBytes_AS_STRING(in);
    1793             :                                 } else {
    1794           0 :                                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(in)->tp_name);
    1795           0 :                                         talloc_free(ret); return NULL;
    1796             :                                 }
    1797         673 :                                 talloc_str = talloc_strdup(mem_ctx, test_str);
    1798         673 :                                 if (unicode != NULL) {
    1799         506 :                                         Py_DECREF(unicode);
    1800             :                                 }
    1801         673 :                                 if (talloc_str == NULL) {
    1802           0 :                                         PyErr_NoMemory();
    1803           0 :                                         talloc_free(ret); return NULL;
    1804             :                                 }
    1805         673 :                                 ret->ipv4 = talloc_str;
    1806             :                         }
    1807         673 :                         break;
    1808             : 
    1809         480 :                 case DNS_TYPE_NS:
    1810         480 :                         if (in == NULL) {
    1811           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->name");
    1812           0 :                                 talloc_free(ret); return NULL;
    1813             :                         }
    1814         480 :                         PY_CHECK_TYPE(&DNS_RPC_NAME_Type, in, talloc_free(ret); return NULL;);
    1815         480 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1816           0 :                                 PyErr_NoMemory();
    1817           0 :                                 talloc_free(ret); return NULL;
    1818             :                         }
    1819         480 :                         ret->name = *(struct DNS_RPC_NAME *)pytalloc_get_ptr(in);
    1820         480 :                         break;
    1821             : 
    1822           0 :                 case DNS_TYPE_MD:
    1823           0 :                         if (in == NULL) {
    1824           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->name");
    1825           0 :                                 talloc_free(ret); return NULL;
    1826             :                         }
    1827           0 :                         PY_CHECK_TYPE(&DNS_RPC_NAME_Type, in, talloc_free(ret); return NULL;);
    1828           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1829           0 :                                 PyErr_NoMemory();
    1830           0 :                                 talloc_free(ret); return NULL;
    1831             :                         }
    1832           0 :                         ret->name = *(struct DNS_RPC_NAME *)pytalloc_get_ptr(in);
    1833           0 :                         break;
    1834             : 
    1835           0 :                 case DNS_TYPE_MF:
    1836           0 :                         if (in == NULL) {
    1837           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->name");
    1838           0 :                                 talloc_free(ret); return NULL;
    1839             :                         }
    1840           0 :                         PY_CHECK_TYPE(&DNS_RPC_NAME_Type, in, talloc_free(ret); return NULL;);
    1841           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1842           0 :                                 PyErr_NoMemory();
    1843           0 :                                 talloc_free(ret); return NULL;
    1844             :                         }
    1845           0 :                         ret->name = *(struct DNS_RPC_NAME *)pytalloc_get_ptr(in);
    1846           0 :                         break;
    1847             : 
    1848         442 :                 case DNS_TYPE_CNAME:
    1849         442 :                         if (in == NULL) {
    1850           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->name");
    1851           0 :                                 talloc_free(ret); return NULL;
    1852             :                         }
    1853         442 :                         PY_CHECK_TYPE(&DNS_RPC_NAME_Type, in, talloc_free(ret); return NULL;);
    1854         442 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1855           0 :                                 PyErr_NoMemory();
    1856           0 :                                 talloc_free(ret); return NULL;
    1857             :                         }
    1858         442 :                         ret->name = *(struct DNS_RPC_NAME *)pytalloc_get_ptr(in);
    1859         442 :                         break;
    1860             : 
    1861           0 :                 case DNS_TYPE_SOA:
    1862           0 :                         if (in == NULL) {
    1863           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->soa");
    1864           0 :                                 talloc_free(ret); return NULL;
    1865             :                         }
    1866           0 :                         PY_CHECK_TYPE(&DNS_RPC_RECORD_SOA_Type, in, talloc_free(ret); return NULL;);
    1867           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1868           0 :                                 PyErr_NoMemory();
    1869           0 :                                 talloc_free(ret); return NULL;
    1870             :                         }
    1871           0 :                         ret->soa = *(struct DNS_RPC_RECORD_SOA *)pytalloc_get_ptr(in);
    1872           0 :                         break;
    1873             : 
    1874           0 :                 case DNS_TYPE_MB:
    1875           0 :                         if (in == NULL) {
    1876           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->name");
    1877           0 :                                 talloc_free(ret); return NULL;
    1878             :                         }
    1879           0 :                         PY_CHECK_TYPE(&DNS_RPC_NAME_Type, in, talloc_free(ret); return NULL;);
    1880           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1881           0 :                                 PyErr_NoMemory();
    1882           0 :                                 talloc_free(ret); return NULL;
    1883             :                         }
    1884           0 :                         ret->name = *(struct DNS_RPC_NAME *)pytalloc_get_ptr(in);
    1885           0 :                         break;
    1886             : 
    1887           0 :                 case DNS_TYPE_MG:
    1888           0 :                         if (in == NULL) {
    1889           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->name");
    1890           0 :                                 talloc_free(ret); return NULL;
    1891             :                         }
    1892           0 :                         PY_CHECK_TYPE(&DNS_RPC_NAME_Type, in, talloc_free(ret); return NULL;);
    1893           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1894           0 :                                 PyErr_NoMemory();
    1895           0 :                                 talloc_free(ret); return NULL;
    1896             :                         }
    1897           0 :                         ret->name = *(struct DNS_RPC_NAME *)pytalloc_get_ptr(in);
    1898           0 :                         break;
    1899             : 
    1900           0 :                 case DNS_TYPE_MR:
    1901           0 :                         if (in == NULL) {
    1902           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->name");
    1903           0 :                                 talloc_free(ret); return NULL;
    1904             :                         }
    1905           0 :                         PY_CHECK_TYPE(&DNS_RPC_NAME_Type, in, talloc_free(ret); return NULL;);
    1906           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1907           0 :                                 PyErr_NoMemory();
    1908           0 :                                 talloc_free(ret); return NULL;
    1909             :                         }
    1910           0 :                         ret->name = *(struct DNS_RPC_NAME *)pytalloc_get_ptr(in);
    1911           0 :                         break;
    1912             : 
    1913         474 :                 case DNS_TYPE_PTR:
    1914         474 :                         if (in == NULL) {
    1915           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->ptr");
    1916           0 :                                 talloc_free(ret); return NULL;
    1917             :                         }
    1918         474 :                         PY_CHECK_TYPE(&DNS_RPC_NAME_Type, in, talloc_free(ret); return NULL;);
    1919         474 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1920           0 :                                 PyErr_NoMemory();
    1921           0 :                                 talloc_free(ret); return NULL;
    1922             :                         }
    1923         474 :                         ret->ptr = *(struct DNS_RPC_NAME *)pytalloc_get_ptr(in);
    1924         474 :                         break;
    1925             : 
    1926           0 :                 case DNS_TYPE_HINFO:
    1927           0 :                         if (in == NULL) {
    1928           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->hinfo");
    1929           0 :                                 talloc_free(ret); return NULL;
    1930             :                         }
    1931           0 :                         PY_CHECK_TYPE(&DNS_RPC_NAME_Type, in, talloc_free(ret); return NULL;);
    1932           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1933           0 :                                 PyErr_NoMemory();
    1934           0 :                                 talloc_free(ret); return NULL;
    1935             :                         }
    1936           0 :                         ret->hinfo = *(struct DNS_RPC_NAME *)pytalloc_get_ptr(in);
    1937           0 :                         break;
    1938             : 
    1939         433 :                 case DNS_TYPE_MX:
    1940         433 :                         if (in == NULL) {
    1941           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->mx");
    1942           0 :                                 talloc_free(ret); return NULL;
    1943             :                         }
    1944         433 :                         PY_CHECK_TYPE(&DNS_RPC_RECORD_NAME_PREFERENCE_Type, in, talloc_free(ret); return NULL;);
    1945         433 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1946           0 :                                 PyErr_NoMemory();
    1947           0 :                                 talloc_free(ret); return NULL;
    1948             :                         }
    1949         433 :                         ret->mx = *(struct DNS_RPC_RECORD_NAME_PREFERENCE *)pytalloc_get_ptr(in);
    1950         433 :                         break;
    1951             : 
    1952         371 :                 case DNS_TYPE_TXT:
    1953         371 :                         if (in == NULL) {
    1954           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->txt");
    1955           0 :                                 talloc_free(ret); return NULL;
    1956             :                         }
    1957         371 :                         PY_CHECK_TYPE(&DNS_RPC_RECORD_STRING_Type, in, talloc_free(ret); return NULL;);
    1958         371 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    1959           0 :                                 PyErr_NoMemory();
    1960           0 :                                 talloc_free(ret); return NULL;
    1961             :                         }
    1962         371 :                         ret->txt = *(struct DNS_RPC_RECORD_STRING *)pytalloc_get_ptr(in);
    1963         371 :                         break;
    1964             : 
    1965         760 :                 case DNS_TYPE_AAAA:
    1966         760 :                         if (in == NULL) {
    1967           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->ipv6");
    1968           0 :                                 talloc_free(ret); return NULL;
    1969             :                         }
    1970             :                         {
    1971           0 :                                 const char *test_str;
    1972           0 :                                 const char *talloc_str;
    1973         760 :                                 PyObject *unicode = NULL;
    1974         760 :                                 if (PyUnicode_Check(in)) {
    1975         760 :                                         unicode = PyUnicode_AsEncodedString(in, "utf-8", "ignore");
    1976         760 :                                         if (unicode == NULL) {
    1977           0 :                                                 talloc_free(ret); return NULL;
    1978             :                                         }
    1979         760 :                                         test_str = PyBytes_AS_STRING(unicode);
    1980           0 :                                 } else if (PyBytes_Check(in)) {
    1981           0 :                                         test_str = PyBytes_AS_STRING(in);
    1982             :                                 } else {
    1983           0 :                                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(in)->tp_name);
    1984           0 :                                         talloc_free(ret); return NULL;
    1985             :                                 }
    1986         760 :                                 talloc_str = talloc_strdup(mem_ctx, test_str);
    1987         760 :                                 if (unicode != NULL) {
    1988         562 :                                         Py_DECREF(unicode);
    1989             :                                 }
    1990         760 :                                 if (talloc_str == NULL) {
    1991           0 :                                         PyErr_NoMemory();
    1992           0 :                                         talloc_free(ret); return NULL;
    1993             :                                 }
    1994         760 :                                 ret->ipv6 = talloc_str;
    1995             :                         }
    1996         760 :                         break;
    1997             : 
    1998         582 :                 case DNS_TYPE_SRV:
    1999         582 :                         if (in == NULL) {
    2000           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->srv");
    2001           0 :                                 talloc_free(ret); return NULL;
    2002             :                         }
    2003         582 :                         PY_CHECK_TYPE(&DNS_RPC_RECORD_SRV_Type, in, talloc_free(ret); return NULL;);
    2004         582 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    2005           0 :                                 PyErr_NoMemory();
    2006           0 :                                 talloc_free(ret); return NULL;
    2007             :                         }
    2008         582 :                         ret->srv = *(struct DNS_RPC_RECORD_SRV *)pytalloc_get_ptr(in);
    2009         582 :                         break;
    2010             : 
    2011           0 :                 case DNS_TYPE_DNAME:
    2012           0 :                         if (in == NULL) {
    2013           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->name");
    2014           0 :                                 talloc_free(ret); return NULL;
    2015             :                         }
    2016           0 :                         PY_CHECK_TYPE(&DNS_RPC_NAME_Type, in, talloc_free(ret); return NULL;);
    2017           0 :                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
    2018           0 :                                 PyErr_NoMemory();
    2019           0 :                                 talloc_free(ret); return NULL;
    2020             :                         }
    2021           0 :                         ret->name = *(struct DNS_RPC_NAME *)pytalloc_get_ptr(in);
    2022           0 :                         break;
    2023             : 
    2024           0 :                 default:
    2025           0 :                         PyErr_SetString(PyExc_TypeError, "invalid union level value");
    2026           0 :                         talloc_free(ret);
    2027           0 :                         ret = NULL;
    2028             :         }
    2029             : 
    2030        4215 :         return ret;
    2031             : }
    2032             : 
    2033         766 : static PyObject *py_DNS_RPC_RECORD_DATA_import(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    2034             : {
    2035         766 :         const char * const kwnames[] = { "mem_ctx", "level", "in", NULL };
    2036         766 :         PyObject *mem_ctx_obj = NULL;
    2037         766 :         TALLOC_CTX *mem_ctx = NULL;
    2038         766 :         int level = 0;
    2039         766 :         PyObject *in_obj = NULL;
    2040         766 :         union DNS_RPC_RECORD_DATA *in = NULL;
    2041             : 
    2042         766 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OiO:import",
    2043             :                 discard_const_p(char *, kwnames),
    2044             :                 &mem_ctx_obj,
    2045             :                 &level,
    2046             :                 &in_obj)) {
    2047           0 :                 return NULL;
    2048             :         }
    2049         766 :         mem_ctx = pytalloc_get_ptr(mem_ctx_obj);
    2050         766 :         if (mem_ctx == NULL) {
    2051           0 :                 PyErr_SetString(PyExc_TypeError, "mem_ctx is NULL)!");
    2052           0 :                 return NULL;
    2053             :         }
    2054         766 :         in = (union DNS_RPC_RECORD_DATA *)pytalloc_get_ptr(in_obj);
    2055         766 :         if (in == NULL) {
    2056           0 :                 PyErr_Format(PyExc_TypeError, "in needs to be a pointer to union DNS_RPC_RECORD_DATA!");
    2057           0 :                 return NULL;
    2058             :         }
    2059             : 
    2060         766 :         return py_import_DNS_RPC_RECORD_DATA(mem_ctx, level, in);
    2061             : }
    2062             : 
    2063        4215 : static PyObject *py_DNS_RPC_RECORD_DATA_export(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    2064             : {
    2065        4215 :         const char * const kwnames[] = { "mem_ctx", "level", "in", NULL };
    2066        4215 :         PyObject *mem_ctx_obj = NULL;
    2067        4215 :         TALLOC_CTX *mem_ctx = NULL;
    2068        4215 :         int level = 0;
    2069        4215 :         PyObject *in = NULL;
    2070        4215 :         union DNS_RPC_RECORD_DATA *out = NULL;
    2071             : 
    2072        4215 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OiO:export",
    2073             :                 discard_const_p(char *, kwnames),
    2074             :                 &mem_ctx_obj,
    2075             :                 &level,
    2076             :                 &in)) {
    2077           0 :                 return NULL;
    2078             :         }
    2079        4215 :         mem_ctx = pytalloc_get_ptr(mem_ctx_obj);
    2080        4215 :         if (mem_ctx == NULL) {
    2081           0 :                 PyErr_SetString(PyExc_TypeError, "mem_ctx is NULL)!");
    2082           0 :                 return NULL;
    2083             :         }
    2084             : 
    2085        4215 :         out = py_export_DNS_RPC_RECORD_DATA(mem_ctx, level, in);
    2086        4215 :         if (out == NULL) {
    2087           0 :                 return NULL;
    2088             :         }
    2089             : 
    2090        4215 :         return pytalloc_GenericObject_reference(out);
    2091             : }
    2092             : 
    2093             : static PyMethodDef py_DNS_RPC_RECORD_DATA_methods[] = {
    2094             :         { "__import__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DNS_RPC_RECORD_DATA_import),
    2095             :                 METH_VARARGS|METH_KEYWORDS|METH_CLASS,
    2096             :                 "T.__import__(mem_ctx, level, in) => ret." },
    2097             :         { "__export__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DNS_RPC_RECORD_DATA_export),
    2098             :                 METH_VARARGS|METH_KEYWORDS|METH_CLASS,
    2099             :                 "T.__export__(mem_ctx, level, in) => ret." },
    2100             :         { NULL, NULL, 0, NULL }
    2101             : };
    2102             : 
    2103           0 : static PyObject *py_DNS_RPC_RECORD_DATA_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    2104             : {
    2105           0 :         PyErr_Format(PyExc_TypeError, "New %s Objects are not supported", type->tp_name);
    2106           0 :         return NULL;
    2107             : }
    2108             : 
    2109             : 
    2110             : static PyTypeObject DNS_RPC_RECORD_DATA_Type = {
    2111             :         PyVarObject_HEAD_INIT(NULL, 0)
    2112             :         .tp_name = "dnsserver.DNS_RPC_RECORD_DATA",
    2113             :         .tp_getset = NULL,
    2114             :         .tp_methods = py_DNS_RPC_RECORD_DATA_methods,
    2115             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    2116             :         .tp_new = py_DNS_RPC_RECORD_DATA_new,
    2117             : };
    2118             : 
    2119             : 
    2120           0 : static PyObject *py_DNS_RPC_RECORD_get_wDataLength(PyObject *obj, void *closure)
    2121             : {
    2122           0 :         struct DNS_RPC_RECORD *object = pytalloc_get_ptr(obj);
    2123           0 :         PyObject *py_wDataLength;
    2124           0 :         py_wDataLength = PyLong_FromLong((uint16_t)(object->wDataLength));
    2125           0 :         return py_wDataLength;
    2126             : }
    2127             : 
    2128           0 : static int py_DNS_RPC_RECORD_set_wDataLength(PyObject *py_obj, PyObject *value, void *closure)
    2129             : {
    2130           0 :         struct DNS_RPC_RECORD *object = pytalloc_get_ptr(py_obj);
    2131           0 :         if (value == NULL) {
    2132           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->wDataLength");
    2133           0 :                 return -1;
    2134             :         }
    2135             :         {
    2136           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->wDataLength));
    2137           0 :                 if (PyLong_Check(value)) {
    2138           0 :                         unsigned long long test_var;
    2139           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    2140           0 :                         if (PyErr_Occurred() != NULL) {
    2141           0 :                                 return -1;
    2142             :                         }
    2143           0 :                         if (test_var > uint_max) {
    2144           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2145             :                                   PyLong_Type.tp_name, uint_max, test_var);
    2146           0 :                                 return -1;
    2147             :                         }
    2148           0 :                         object->wDataLength = test_var;
    2149             :                 } else {
    2150           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2151             :                           PyLong_Type.tp_name);
    2152           0 :                         return -1;
    2153             :                 }
    2154             :         }
    2155           0 :         return 0;
    2156             : }
    2157             : 
    2158         822 : static PyObject *py_DNS_RPC_RECORD_get_wType(PyObject *obj, void *closure)
    2159             : {
    2160         822 :         struct DNS_RPC_RECORD *object = pytalloc_get_ptr(obj);
    2161           0 :         PyObject *py_wType;
    2162         822 :         py_wType = PyLong_FromLong((uint16_t)(object->wType));
    2163         822 :         return py_wType;
    2164             : }
    2165             : 
    2166        4227 : static int py_DNS_RPC_RECORD_set_wType(PyObject *py_obj, PyObject *value, void *closure)
    2167             : {
    2168        4227 :         struct DNS_RPC_RECORD *object = pytalloc_get_ptr(py_obj);
    2169        4227 :         if (value == NULL) {
    2170           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->wType");
    2171           0 :                 return -1;
    2172             :         }
    2173             :         {
    2174        4227 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->wType));
    2175        4227 :                 if (PyLong_Check(value)) {
    2176           0 :                         unsigned long long test_var;
    2177        4227 :                         test_var = PyLong_AsUnsignedLongLong(value);
    2178        4227 :                         if (PyErr_Occurred() != NULL) {
    2179           0 :                                 return -1;
    2180             :                         }
    2181        4227 :                         if (test_var > uint_max) {
    2182           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2183             :                                   PyLong_Type.tp_name, uint_max, test_var);
    2184           0 :                                 return -1;
    2185             :                         }
    2186        4227 :                         object->wType = test_var;
    2187             :                 } else {
    2188           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2189             :                           PyLong_Type.tp_name);
    2190           0 :                         return -1;
    2191             :                 }
    2192             :         }
    2193        4227 :         return 0;
    2194             : }
    2195             : 
    2196         218 : static PyObject *py_DNS_RPC_RECORD_get_dwFlags(PyObject *obj, void *closure)
    2197             : {
    2198         218 :         struct DNS_RPC_RECORD *object = pytalloc_get_ptr(obj);
    2199           0 :         PyObject *py_dwFlags;
    2200         218 :         py_dwFlags = PyLong_FromUnsignedLongLong((uint32_t)(object->dwFlags));
    2201         218 :         return py_dwFlags;
    2202             : }
    2203             : 
    2204        4325 : static int py_DNS_RPC_RECORD_set_dwFlags(PyObject *py_obj, PyObject *value, void *closure)
    2205             : {
    2206        4325 :         struct DNS_RPC_RECORD *object = pytalloc_get_ptr(py_obj);
    2207        4325 :         if (value == NULL) {
    2208           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwFlags");
    2209           0 :                 return -1;
    2210             :         }
    2211             :         {
    2212        4325 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwFlags));
    2213        4325 :                 if (PyLong_Check(value)) {
    2214           0 :                         unsigned long long test_var;
    2215        4325 :                         test_var = PyLong_AsUnsignedLongLong(value);
    2216        4325 :                         if (PyErr_Occurred() != NULL) {
    2217           0 :                                 return -1;
    2218             :                         }
    2219        4325 :                         if (test_var > uint_max) {
    2220           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2221             :                                   PyLong_Type.tp_name, uint_max, test_var);
    2222           0 :                                 return -1;
    2223             :                         }
    2224        4325 :                         object->dwFlags = test_var;
    2225             :                 } else {
    2226           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2227             :                           PyLong_Type.tp_name);
    2228           0 :                         return -1;
    2229             :                 }
    2230             :         }
    2231        4325 :         return 0;
    2232             : }
    2233             : 
    2234         218 : static PyObject *py_DNS_RPC_RECORD_get_dwSerial(PyObject *obj, void *closure)
    2235             : {
    2236         218 :         struct DNS_RPC_RECORD *object = pytalloc_get_ptr(obj);
    2237           0 :         PyObject *py_dwSerial;
    2238         218 :         py_dwSerial = PyLong_FromUnsignedLongLong((uint32_t)(object->dwSerial));
    2239         218 :         return py_dwSerial;
    2240             : }
    2241             : 
    2242        4325 : static int py_DNS_RPC_RECORD_set_dwSerial(PyObject *py_obj, PyObject *value, void *closure)
    2243             : {
    2244        4325 :         struct DNS_RPC_RECORD *object = pytalloc_get_ptr(py_obj);
    2245        4325 :         if (value == NULL) {
    2246           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwSerial");
    2247           0 :                 return -1;
    2248             :         }
    2249             :         {
    2250        4325 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwSerial));
    2251        4325 :                 if (PyLong_Check(value)) {
    2252           0 :                         unsigned long long test_var;
    2253        4325 :                         test_var = PyLong_AsUnsignedLongLong(value);
    2254        4325 :                         if (PyErr_Occurred() != NULL) {
    2255           0 :                                 return -1;
    2256             :                         }
    2257        4325 :                         if (test_var > uint_max) {
    2258           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2259             :                                   PyLong_Type.tp_name, uint_max, test_var);
    2260           0 :                                 return -1;
    2261             :                         }
    2262        4325 :                         object->dwSerial = test_var;
    2263             :                 } else {
    2264           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2265             :                           PyLong_Type.tp_name);
    2266           0 :                         return -1;
    2267             :                 }
    2268             :         }
    2269        4325 :         return 0;
    2270             : }
    2271             : 
    2272         218 : static PyObject *py_DNS_RPC_RECORD_get_dwTtlSeconds(PyObject *obj, void *closure)
    2273             : {
    2274         218 :         struct DNS_RPC_RECORD *object = pytalloc_get_ptr(obj);
    2275           0 :         PyObject *py_dwTtlSeconds;
    2276         218 :         py_dwTtlSeconds = PyLong_FromUnsignedLongLong((uint32_t)(object->dwTtlSeconds));
    2277         218 :         return py_dwTtlSeconds;
    2278             : }
    2279             : 
    2280        4329 : static int py_DNS_RPC_RECORD_set_dwTtlSeconds(PyObject *py_obj, PyObject *value, void *closure)
    2281             : {
    2282        4329 :         struct DNS_RPC_RECORD *object = pytalloc_get_ptr(py_obj);
    2283        4329 :         if (value == NULL) {
    2284           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwTtlSeconds");
    2285           0 :                 return -1;
    2286             :         }
    2287             :         {
    2288        4329 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwTtlSeconds));
    2289        4329 :                 if (PyLong_Check(value)) {
    2290           0 :                         unsigned long long test_var;
    2291        4329 :                         test_var = PyLong_AsUnsignedLongLong(value);
    2292        4329 :                         if (PyErr_Occurred() != NULL) {
    2293           0 :                                 return -1;
    2294             :                         }
    2295        4329 :                         if (test_var > uint_max) {
    2296           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2297             :                                   PyLong_Type.tp_name, uint_max, test_var);
    2298           0 :                                 return -1;
    2299             :                         }
    2300        4329 :                         object->dwTtlSeconds = test_var;
    2301             :                 } else {
    2302           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2303             :                           PyLong_Type.tp_name);
    2304           0 :                         return -1;
    2305             :                 }
    2306             :         }
    2307        4329 :         return 0;
    2308             : }
    2309             : 
    2310          94 : static PyObject *py_DNS_RPC_RECORD_get_dwTimeStamp(PyObject *obj, void *closure)
    2311             : {
    2312          94 :         struct DNS_RPC_RECORD *object = pytalloc_get_ptr(obj);
    2313           0 :         PyObject *py_dwTimeStamp;
    2314          94 :         py_dwTimeStamp = PyLong_FromUnsignedLongLong((uint32_t)(object->dwTimeStamp));
    2315          94 :         return py_dwTimeStamp;
    2316             : }
    2317             : 
    2318         104 : static int py_DNS_RPC_RECORD_set_dwTimeStamp(PyObject *py_obj, PyObject *value, void *closure)
    2319             : {
    2320         104 :         struct DNS_RPC_RECORD *object = pytalloc_get_ptr(py_obj);
    2321         104 :         if (value == NULL) {
    2322           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwTimeStamp");
    2323           0 :                 return -1;
    2324             :         }
    2325             :         {
    2326         104 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwTimeStamp));
    2327         104 :                 if (PyLong_Check(value)) {
    2328           0 :                         unsigned long long test_var;
    2329         104 :                         test_var = PyLong_AsUnsignedLongLong(value);
    2330         104 :                         if (PyErr_Occurred() != NULL) {
    2331           0 :                                 return -1;
    2332             :                         }
    2333         104 :                         if (test_var > uint_max) {
    2334           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2335             :                                   PyLong_Type.tp_name, uint_max, test_var);
    2336           0 :                                 return -1;
    2337             :                         }
    2338         104 :                         object->dwTimeStamp = test_var;
    2339             :                 } else {
    2340           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2341             :                           PyLong_Type.tp_name);
    2342           0 :                         return -1;
    2343             :                 }
    2344             :         }
    2345         104 :         return 0;
    2346             : }
    2347             : 
    2348           0 : static PyObject *py_DNS_RPC_RECORD_get_dwReserved(PyObject *obj, void *closure)
    2349             : {
    2350           0 :         struct DNS_RPC_RECORD *object = pytalloc_get_ptr(obj);
    2351           0 :         PyObject *py_dwReserved;
    2352           0 :         py_dwReserved = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved));
    2353           0 :         return py_dwReserved;
    2354             : }
    2355             : 
    2356           8 : static int py_DNS_RPC_RECORD_set_dwReserved(PyObject *py_obj, PyObject *value, void *closure)
    2357             : {
    2358           8 :         struct DNS_RPC_RECORD *object = pytalloc_get_ptr(py_obj);
    2359           8 :         if (value == NULL) {
    2360           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved");
    2361           0 :                 return -1;
    2362             :         }
    2363             :         {
    2364           8 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved));
    2365           8 :                 if (PyLong_Check(value)) {
    2366           0 :                         unsigned long long test_var;
    2367           8 :                         test_var = PyLong_AsUnsignedLongLong(value);
    2368           8 :                         if (PyErr_Occurred() != NULL) {
    2369           0 :                                 return -1;
    2370             :                         }
    2371           8 :                         if (test_var > uint_max) {
    2372           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2373             :                                   PyLong_Type.tp_name, uint_max, test_var);
    2374           0 :                                 return -1;
    2375             :                         }
    2376           8 :                         object->dwReserved = test_var;
    2377             :                 } else {
    2378           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2379             :                           PyLong_Type.tp_name);
    2380           0 :                         return -1;
    2381             :                 }
    2382             :         }
    2383           8 :         return 0;
    2384             : }
    2385             : 
    2386         766 : static PyObject *py_DNS_RPC_RECORD_get_data(PyObject *obj, void *closure)
    2387             : {
    2388         766 :         struct DNS_RPC_RECORD *object = pytalloc_get_ptr(obj);
    2389           0 :         PyObject *py_data;
    2390         766 :         py_data = pyrpc_import_union(&DNS_RPC_RECORD_DATA_Type, pytalloc_get_mem_ctx(obj), object->wType, &object->data, "union DNS_RPC_RECORD_DATA");
    2391         766 :         if (py_data == NULL) {
    2392           0 :                 return NULL;
    2393             :         }
    2394         766 :         return py_data;
    2395             : }
    2396             : 
    2397        4215 : static int py_DNS_RPC_RECORD_set_data(PyObject *py_obj, PyObject *value, void *closure)
    2398             : {
    2399        4215 :         struct DNS_RPC_RECORD *object = pytalloc_get_ptr(py_obj);
    2400        4215 :         if (value == NULL) {
    2401           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->data");
    2402           0 :                 return -1;
    2403             :         }
    2404             :         {
    2405           0 :                 union DNS_RPC_RECORD_DATA *data_switch_1;
    2406        4215 :                 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");
    2407        4215 :                 if (data_switch_1 == NULL) {
    2408           0 :                         return -1;
    2409             :                 }
    2410        4215 :                 object->data = *data_switch_1;
    2411             :         }
    2412        4215 :         return 0;
    2413             : }
    2414             : 
    2415             : static PyGetSetDef py_DNS_RPC_RECORD_getsetters[] = {
    2416             :         {
    2417             :                 .name = discard_const_p(char, "wDataLength"),
    2418             :                 .get = py_DNS_RPC_RECORD_get_wDataLength,
    2419             :                 .set = py_DNS_RPC_RECORD_set_wDataLength,
    2420             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
    2421             :         },
    2422             :         {
    2423             :                 .name = discard_const_p(char, "wType"),
    2424             :                 .get = py_DNS_RPC_RECORD_get_wType,
    2425             :                 .set = py_DNS_RPC_RECORD_set_wType,
    2426             :                 .doc = discard_const_p(char, "PIDL-generated element of base type dns_record_type")
    2427             :         },
    2428             :         {
    2429             :                 .name = discard_const_p(char, "dwFlags"),
    2430             :                 .get = py_DNS_RPC_RECORD_get_dwFlags,
    2431             :                 .set = py_DNS_RPC_RECORD_set_dwFlags,
    2432             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    2433             :         },
    2434             :         {
    2435             :                 .name = discard_const_p(char, "dwSerial"),
    2436             :                 .get = py_DNS_RPC_RECORD_get_dwSerial,
    2437             :                 .set = py_DNS_RPC_RECORD_set_dwSerial,
    2438             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    2439             :         },
    2440             :         {
    2441             :                 .name = discard_const_p(char, "dwTtlSeconds"),
    2442             :                 .get = py_DNS_RPC_RECORD_get_dwTtlSeconds,
    2443             :                 .set = py_DNS_RPC_RECORD_set_dwTtlSeconds,
    2444             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    2445             :         },
    2446             :         {
    2447             :                 .name = discard_const_p(char, "dwTimeStamp"),
    2448             :                 .get = py_DNS_RPC_RECORD_get_dwTimeStamp,
    2449             :                 .set = py_DNS_RPC_RECORD_set_dwTimeStamp,
    2450             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    2451             :         },
    2452             :         {
    2453             :                 .name = discard_const_p(char, "dwReserved"),
    2454             :                 .get = py_DNS_RPC_RECORD_get_dwReserved,
    2455             :                 .set = py_DNS_RPC_RECORD_set_dwReserved,
    2456             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    2457             :         },
    2458             :         {
    2459             :                 .name = discard_const_p(char, "data"),
    2460             :                 .get = py_DNS_RPC_RECORD_get_data,
    2461             :                 .set = py_DNS_RPC_RECORD_set_data,
    2462             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_RECORD_DATA")
    2463             :         },
    2464             :         { .name = NULL }
    2465             : };
    2466             : 
    2467        4227 : static PyObject *py_DNS_RPC_RECORD_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    2468             : {
    2469        4227 :         return pytalloc_new(struct DNS_RPC_RECORD, type);
    2470             : }
    2471             : 
    2472           0 : static PyObject *py_DNS_RPC_RECORD_ndr_pack(PyObject *py_obj,  PyObject *Py_UNUSED(ignored))
    2473             : {
    2474           0 :         struct DNS_RPC_RECORD *object = pytalloc_get_ptr(py_obj);
    2475           0 :         PyObject *ret = NULL;
    2476           0 :         DATA_BLOB blob;
    2477           0 :         enum ndr_err_code err;
    2478           0 :         TALLOC_CTX *tmp_ctx = talloc_new(pytalloc_get_mem_ctx(py_obj));
    2479           0 :         if (tmp_ctx == NULL) {
    2480           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    2481           0 :                 return NULL;
    2482             :         }
    2483           0 :         err = ndr_push_struct_blob(&blob, tmp_ctx, object, (ndr_push_flags_fn_t)ndr_push_DNS_RPC_RECORD);
    2484           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    2485           0 :                 TALLOC_FREE(tmp_ctx);
    2486           0 :                 PyErr_SetNdrError(err);
    2487           0 :                 return NULL;
    2488             :         }
    2489             : 
    2490           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
    2491           0 :         TALLOC_FREE(tmp_ctx);
    2492           0 :         return ret;
    2493             : }
    2494             : 
    2495           0 : static PyObject *py_DNS_RPC_RECORD_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    2496             : {
    2497           0 :         struct DNS_RPC_RECORD *object = pytalloc_get_ptr(py_obj);
    2498           0 :         DATA_BLOB blob = {.data = NULL, .length = 0};
    2499           0 :         Py_ssize_t blob_length = 0;
    2500           0 :         enum ndr_err_code err;
    2501           0 :         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
    2502           0 :         PyObject *allow_remaining_obj = NULL;
    2503           0 :         bool allow_remaining = false;
    2504             : 
    2505           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|O:__ndr_unpack__",
    2506             :                 discard_const_p(char *, kwnames),
    2507             :                 &blob.data, &blob_length,
    2508             :                 &allow_remaining_obj)) {
    2509           0 :                 return NULL;
    2510             :         }
    2511           0 :         blob.length = blob_length;
    2512             : 
    2513           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    2514           0 :                 allow_remaining = true;
    2515             :         }
    2516             : 
    2517           0 :         if (allow_remaining) {
    2518           0 :                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_DNS_RPC_RECORD);
    2519             :         } else {
    2520           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);
    2521             :         }
    2522           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    2523           0 :                 PyErr_SetNdrError(err);
    2524           0 :                 return NULL;
    2525             :         }
    2526             : 
    2527           0 :         Py_RETURN_NONE;
    2528             : }
    2529             : 
    2530           0 : static PyObject *py_DNS_RPC_RECORD_ndr_print(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    2531             : {
    2532           0 :         struct DNS_RPC_RECORD *object = pytalloc_get_ptr(py_obj);
    2533           0 :         PyObject *ret;
    2534           0 :         char *retstr;
    2535             : 
    2536           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);
    2537           0 :         ret = PyUnicode_FromString(retstr);
    2538           0 :         talloc_free(retstr);
    2539             : 
    2540           0 :         return ret;
    2541             : }
    2542             : 
    2543             : static PyMethodDef py_DNS_RPC_RECORD_methods[] = {
    2544             :         { "__ndr_pack__", (PyCFunction)py_DNS_RPC_RECORD_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
    2545             :         { "__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" },
    2546             :         { "__ndr_print__", (PyCFunction)py_DNS_RPC_RECORD_ndr_print, METH_NOARGS, "S.ndr_print(object) -> None\nNDR print" },
    2547             :         { NULL, NULL, 0, NULL }
    2548             : };
    2549             : 
    2550             : 
    2551             : static PyTypeObject DNS_RPC_RECORD_Type = {
    2552             :         PyVarObject_HEAD_INIT(NULL, 0)
    2553             :         .tp_name = "dnsserver.DNS_RPC_RECORD",
    2554             :         .tp_getset = py_DNS_RPC_RECORD_getsetters,
    2555             :         .tp_methods = py_DNS_RPC_RECORD_methods,
    2556             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    2557             :         .tp_new = py_DNS_RPC_RECORD_new,
    2558             : };
    2559             : 
    2560             : 
    2561           0 : static PyObject *py_DNS_RPC_RECORD_BUF_get_wContextLength(PyObject *obj, void *closure)
    2562             : {
    2563           0 :         struct DNS_RPC_RECORD_BUF *object = pytalloc_get_ptr(obj);
    2564           0 :         PyObject *py_wContextLength;
    2565           0 :         py_wContextLength = PyLong_FromUnsignedLongLong((uint32_t)(object->wContextLength));
    2566           0 :         return py_wContextLength;
    2567             : }
    2568             : 
    2569           0 : static int py_DNS_RPC_RECORD_BUF_set_wContextLength(PyObject *py_obj, PyObject *value, void *closure)
    2570             : {
    2571           0 :         struct DNS_RPC_RECORD_BUF *object = pytalloc_get_ptr(py_obj);
    2572           0 :         if (value == NULL) {
    2573           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->wContextLength");
    2574           0 :                 return -1;
    2575             :         }
    2576             :         {
    2577           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->wContextLength));
    2578           0 :                 if (PyLong_Check(value)) {
    2579           0 :                         unsigned long long test_var;
    2580           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    2581           0 :                         if (PyErr_Occurred() != NULL) {
    2582           0 :                                 return -1;
    2583             :                         }
    2584           0 :                         if (test_var > uint_max) {
    2585           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2586             :                                   PyLong_Type.tp_name, uint_max, test_var);
    2587           0 :                                 return -1;
    2588             :                         }
    2589           0 :                         object->wContextLength = test_var;
    2590             :                 } else {
    2591           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2592             :                           PyLong_Type.tp_name);
    2593           0 :                         return -1;
    2594             :                 }
    2595             :         }
    2596           0 :         return 0;
    2597             : }
    2598             : 
    2599           0 : static PyObject *py_DNS_RPC_RECORD_BUF_get_rec(PyObject *obj, void *closure)
    2600             : {
    2601           0 :         struct DNS_RPC_RECORD_BUF *object = pytalloc_get_ptr(obj);
    2602           0 :         PyObject *py_rec;
    2603           0 :         py_rec = pytalloc_reference_ex(&DNS_RPC_RECORD_Type, pytalloc_get_mem_ctx(obj), &object->rec);
    2604           0 :         return py_rec;
    2605             : }
    2606             : 
    2607        4197 : static int py_DNS_RPC_RECORD_BUF_set_rec(PyObject *py_obj, PyObject *value, void *closure)
    2608             : {
    2609        4197 :         struct DNS_RPC_RECORD_BUF *object = pytalloc_get_ptr(py_obj);
    2610        4197 :         if (value == NULL) {
    2611           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->rec");
    2612           0 :                 return -1;
    2613             :         }
    2614        4197 :         PY_CHECK_TYPE(&DNS_RPC_RECORD_Type, value, return -1;);
    2615        4197 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    2616           0 :                 PyErr_NoMemory();
    2617           0 :                 return -1;
    2618             :         }
    2619        4197 :         object->rec = *(struct DNS_RPC_RECORD *)pytalloc_get_ptr(value);
    2620        4197 :         return 0;
    2621             : }
    2622             : 
    2623             : static PyGetSetDef py_DNS_RPC_RECORD_BUF_getsetters[] = {
    2624             :         {
    2625             :                 .name = discard_const_p(char, "wContextLength"),
    2626             :                 .get = py_DNS_RPC_RECORD_BUF_get_wContextLength,
    2627             :                 .set = py_DNS_RPC_RECORD_BUF_set_wContextLength,
    2628             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint3264")
    2629             :         },
    2630             :         {
    2631             :                 .name = discard_const_p(char, "rec"),
    2632             :                 .get = py_DNS_RPC_RECORD_BUF_get_rec,
    2633             :                 .set = py_DNS_RPC_RECORD_BUF_set_rec,
    2634             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_RECORD")
    2635             :         },
    2636             :         { .name = NULL }
    2637             : };
    2638             : 
    2639        4197 : static PyObject *py_DNS_RPC_RECORD_BUF_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    2640             : {
    2641        4197 :         return pytalloc_new(struct DNS_RPC_RECORD_BUF, type);
    2642             : }
    2643             : 
    2644             : 
    2645             : static PyTypeObject DNS_RPC_RECORD_BUF_Type = {
    2646             :         PyVarObject_HEAD_INIT(NULL, 0)
    2647             :         .tp_name = "dnsserver.DNS_RPC_RECORD_BUF",
    2648             :         .tp_getset = py_DNS_RPC_RECORD_BUF_getsetters,
    2649             :         .tp_methods = NULL,
    2650             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    2651             :         .tp_new = py_DNS_RPC_RECORD_BUF_new,
    2652             : };
    2653             : 
    2654             : 
    2655           4 : static PyObject *py_IP4_ARRAY_get_AddrCount(PyObject *obj, void *closure)
    2656             : {
    2657           4 :         struct IP4_ARRAY *object = pytalloc_get_ptr(obj);
    2658           0 :         PyObject *py_AddrCount;
    2659           4 :         py_AddrCount = PyLong_FromUnsignedLongLong((uint32_t)(object->AddrCount));
    2660           4 :         return py_AddrCount;
    2661             : }
    2662             : 
    2663           0 : static int py_IP4_ARRAY_set_AddrCount(PyObject *py_obj, PyObject *value, void *closure)
    2664             : {
    2665           0 :         struct IP4_ARRAY *object = pytalloc_get_ptr(py_obj);
    2666           0 :         if (value == NULL) {
    2667           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->AddrCount");
    2668           0 :                 return -1;
    2669             :         }
    2670             :         {
    2671           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->AddrCount));
    2672           0 :                 if (PyLong_Check(value)) {
    2673           0 :                         unsigned long long test_var;
    2674           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    2675           0 :                         if (PyErr_Occurred() != NULL) {
    2676           0 :                                 return -1;
    2677             :                         }
    2678           0 :                         if (test_var > uint_max) {
    2679           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2680             :                                   PyLong_Type.tp_name, uint_max, test_var);
    2681           0 :                                 return -1;
    2682             :                         }
    2683           0 :                         object->AddrCount = test_var;
    2684             :                 } else {
    2685           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2686             :                           PyLong_Type.tp_name);
    2687           0 :                         return -1;
    2688             :                 }
    2689             :         }
    2690           0 :         return 0;
    2691             : }
    2692             : 
    2693           4 : static PyObject *py_IP4_ARRAY_get_AddrArray(PyObject *obj, void *closure)
    2694             : {
    2695           4 :         struct IP4_ARRAY *object = pytalloc_get_ptr(obj);
    2696           0 :         PyObject *py_AddrArray;
    2697           4 :         py_AddrArray = PyList_New(object->AddrCount);
    2698           4 :         if (py_AddrArray == NULL) {
    2699           0 :                 return NULL;
    2700             :         }
    2701             :         {
    2702             :                 int AddrArray_cntr_0;
    2703           8 :                 for (AddrArray_cntr_0 = 0; AddrArray_cntr_0 < (object->AddrCount); AddrArray_cntr_0++) {
    2704           0 :                         PyObject *py_AddrArray_0;
    2705           4 :                         py_AddrArray_0 = PyLong_FromUnsignedLongLong((uint32_t)((object->AddrArray)[AddrArray_cntr_0]));
    2706           4 :                         PyList_SetItem(py_AddrArray, AddrArray_cntr_0, py_AddrArray_0);
    2707             :                 }
    2708             :         }
    2709           4 :         return py_AddrArray;
    2710             : }
    2711             : 
    2712           0 : static int py_IP4_ARRAY_set_AddrArray(PyObject *py_obj, PyObject *value, void *closure)
    2713             : {
    2714           0 :         struct IP4_ARRAY *object = pytalloc_get_ptr(py_obj);
    2715           0 :         if (value == NULL) {
    2716           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->AddrArray");
    2717           0 :                 return -1;
    2718             :         }
    2719           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
    2720             :         {
    2721           0 :                 int AddrArray_cntr_0;
    2722           0 :                 object->AddrArray = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->AddrArray, PyList_GET_SIZE(value));
    2723           0 :                 if (!object->AddrArray) { return -1; }
    2724           0 :                 talloc_set_name_const(object->AddrArray, "ARRAY: object->AddrArray");
    2725           0 :                 for (AddrArray_cntr_0 = 0; AddrArray_cntr_0 < PyList_GET_SIZE(value); AddrArray_cntr_0++) {
    2726           0 :                         if (PyList_GET_ITEM(value, AddrArray_cntr_0) == NULL) {
    2727           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->AddrArray)[AddrArray_cntr_0]");
    2728           0 :                                 return -1;
    2729             :                         }
    2730             :                         {
    2731           0 :                                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof((object->AddrArray)[AddrArray_cntr_0]));
    2732           0 :                                 if (PyLong_Check(PyList_GET_ITEM(value, AddrArray_cntr_0))) {
    2733           0 :                                         unsigned long long test_var;
    2734           0 :                                         test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, AddrArray_cntr_0));
    2735           0 :                                         if (PyErr_Occurred() != NULL) {
    2736           0 :                                                 return -1;
    2737             :                                         }
    2738           0 :                                         if (test_var > uint_max) {
    2739           0 :                                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2740             :                                                   PyLong_Type.tp_name, uint_max, test_var);
    2741           0 :                                                 return -1;
    2742             :                                         }
    2743           0 :                                         (object->AddrArray)[AddrArray_cntr_0] = test_var;
    2744             :                                 } else {
    2745           0 :                                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2746             :                                           PyLong_Type.tp_name);
    2747           0 :                                         return -1;
    2748             :                                 }
    2749             :                         }
    2750             :                 }
    2751             :         }
    2752           0 :         return 0;
    2753             : }
    2754             : 
    2755             : static PyGetSetDef py_IP4_ARRAY_getsetters[] = {
    2756             :         {
    2757             :                 .name = discard_const_p(char, "AddrCount"),
    2758             :                 .get = py_IP4_ARRAY_get_AddrCount,
    2759             :                 .set = py_IP4_ARRAY_set_AddrCount,
    2760             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    2761             :         },
    2762             :         {
    2763             :                 .name = discard_const_p(char, "AddrArray"),
    2764             :                 .get = py_IP4_ARRAY_get_AddrArray,
    2765             :                 .set = py_IP4_ARRAY_set_AddrArray,
    2766             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    2767             :         },
    2768             :         { .name = NULL }
    2769             : };
    2770             : 
    2771           0 : static PyObject *py_IP4_ARRAY_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    2772             : {
    2773           0 :         return pytalloc_new(struct IP4_ARRAY, type);
    2774             : }
    2775             : 
    2776             : 
    2777             : static PyTypeObject IP4_ARRAY_Type = {
    2778             :         PyVarObject_HEAD_INIT(NULL, 0)
    2779             :         .tp_name = "dnsserver.IP4_ARRAY",
    2780             :         .tp_getset = py_IP4_ARRAY_getsetters,
    2781             :         .tp_methods = NULL,
    2782             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    2783             :         .tp_new = py_IP4_ARRAY_new,
    2784             : };
    2785             : 
    2786             : 
    2787          10 : static PyObject *py_DNS_ADDR_get_MaxSa(PyObject *obj, void *closure)
    2788             : {
    2789          10 :         struct DNS_ADDR *object = pytalloc_get_ptr(obj);
    2790           0 :         PyObject *py_MaxSa;
    2791          10 :         py_MaxSa = PyList_New(32);
    2792          10 :         if (py_MaxSa == NULL) {
    2793           0 :                 return NULL;
    2794             :         }
    2795             :         {
    2796             :                 int MaxSa_cntr_0;
    2797         330 :                 for (MaxSa_cntr_0 = 0; MaxSa_cntr_0 < (32); MaxSa_cntr_0++) {
    2798           0 :                         PyObject *py_MaxSa_0;
    2799         320 :                         py_MaxSa_0 = PyLong_FromLong((uint16_t)((object->MaxSa)[MaxSa_cntr_0]));
    2800         320 :                         PyList_SetItem(py_MaxSa, MaxSa_cntr_0, py_MaxSa_0);
    2801             :                 }
    2802             :         }
    2803          10 :         return py_MaxSa;
    2804             : }
    2805             : 
    2806           0 : static int py_DNS_ADDR_set_MaxSa(PyObject *py_obj, PyObject *value, void *closure)
    2807             : {
    2808           0 :         struct DNS_ADDR *object = pytalloc_get_ptr(py_obj);
    2809           0 :         if (value == NULL) {
    2810           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->MaxSa");
    2811           0 :                 return -1;
    2812             :         }
    2813           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
    2814             :         {
    2815           0 :                 int MaxSa_cntr_0;
    2816           0 :                 if (ARRAY_SIZE(object->MaxSa) != PyList_GET_SIZE(value)) {
    2817           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));
    2818           0 :                         return -1;
    2819             :                 }
    2820           0 :                 for (MaxSa_cntr_0 = 0; MaxSa_cntr_0 < PyList_GET_SIZE(value); MaxSa_cntr_0++) {
    2821           0 :                         if (PyList_GET_ITEM(value, MaxSa_cntr_0) == NULL) {
    2822           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->MaxSa)[MaxSa_cntr_0]");
    2823           0 :                                 return -1;
    2824             :                         }
    2825             :                         {
    2826           0 :                                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof((object->MaxSa)[MaxSa_cntr_0]));
    2827           0 :                                 if (PyLong_Check(PyList_GET_ITEM(value, MaxSa_cntr_0))) {
    2828           0 :                                         unsigned long long test_var;
    2829           0 :                                         test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, MaxSa_cntr_0));
    2830           0 :                                         if (PyErr_Occurred() != NULL) {
    2831           0 :                                                 return -1;
    2832             :                                         }
    2833           0 :                                         if (test_var > uint_max) {
    2834           0 :                                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2835             :                                                   PyLong_Type.tp_name, uint_max, test_var);
    2836           0 :                                                 return -1;
    2837             :                                         }
    2838           0 :                                         (object->MaxSa)[MaxSa_cntr_0] = test_var;
    2839             :                                 } else {
    2840           0 :                                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2841             :                                           PyLong_Type.tp_name);
    2842           0 :                                         return -1;
    2843             :                                 }
    2844             :                         }
    2845             :                 }
    2846             :         }
    2847           0 :         return 0;
    2848             : }
    2849             : 
    2850           0 : static PyObject *py_DNS_ADDR_get_DnsAddrUserDword(PyObject *obj, void *closure)
    2851             : {
    2852           0 :         struct DNS_ADDR *object = pytalloc_get_ptr(obj);
    2853           0 :         PyObject *py_DnsAddrUserDword;
    2854           0 :         py_DnsAddrUserDword = PyList_New(8);
    2855           0 :         if (py_DnsAddrUserDword == NULL) {
    2856           0 :                 return NULL;
    2857             :         }
    2858             :         {
    2859             :                 int DnsAddrUserDword_cntr_0;
    2860           0 :                 for (DnsAddrUserDword_cntr_0 = 0; DnsAddrUserDword_cntr_0 < (8); DnsAddrUserDword_cntr_0++) {
    2861           0 :                         PyObject *py_DnsAddrUserDword_0;
    2862           0 :                         py_DnsAddrUserDword_0 = PyLong_FromUnsignedLongLong((uint32_t)((object->DnsAddrUserDword)[DnsAddrUserDword_cntr_0]));
    2863           0 :                         PyList_SetItem(py_DnsAddrUserDword, DnsAddrUserDword_cntr_0, py_DnsAddrUserDword_0);
    2864             :                 }
    2865             :         }
    2866           0 :         return py_DnsAddrUserDword;
    2867             : }
    2868             : 
    2869           0 : static int py_DNS_ADDR_set_DnsAddrUserDword(PyObject *py_obj, PyObject *value, void *closure)
    2870             : {
    2871           0 :         struct DNS_ADDR *object = pytalloc_get_ptr(py_obj);
    2872           0 :         if (value == NULL) {
    2873           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->DnsAddrUserDword");
    2874           0 :                 return -1;
    2875             :         }
    2876           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
    2877             :         {
    2878           0 :                 int DnsAddrUserDword_cntr_0;
    2879           0 :                 if (ARRAY_SIZE(object->DnsAddrUserDword) != PyList_GET_SIZE(value)) {
    2880           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));
    2881           0 :                         return -1;
    2882             :                 }
    2883           0 :                 for (DnsAddrUserDword_cntr_0 = 0; DnsAddrUserDword_cntr_0 < PyList_GET_SIZE(value); DnsAddrUserDword_cntr_0++) {
    2884           0 :                         if (PyList_GET_ITEM(value, DnsAddrUserDword_cntr_0) == NULL) {
    2885           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->DnsAddrUserDword)[DnsAddrUserDword_cntr_0]");
    2886           0 :                                 return -1;
    2887             :                         }
    2888             :                         {
    2889           0 :                                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof((object->DnsAddrUserDword)[DnsAddrUserDword_cntr_0]));
    2890           0 :                                 if (PyLong_Check(PyList_GET_ITEM(value, DnsAddrUserDword_cntr_0))) {
    2891           0 :                                         unsigned long long test_var;
    2892           0 :                                         test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, DnsAddrUserDword_cntr_0));
    2893           0 :                                         if (PyErr_Occurred() != NULL) {
    2894           0 :                                                 return -1;
    2895             :                                         }
    2896           0 :                                         if (test_var > uint_max) {
    2897           0 :                                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2898             :                                                   PyLong_Type.tp_name, uint_max, test_var);
    2899           0 :                                                 return -1;
    2900             :                                         }
    2901           0 :                                         (object->DnsAddrUserDword)[DnsAddrUserDword_cntr_0] = test_var;
    2902             :                                 } else {
    2903           0 :                                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2904             :                                           PyLong_Type.tp_name);
    2905           0 :                                         return -1;
    2906             :                                 }
    2907             :                         }
    2908             :                 }
    2909             :         }
    2910           0 :         return 0;
    2911             : }
    2912             : 
    2913             : static PyGetSetDef py_DNS_ADDR_getsetters[] = {
    2914             :         {
    2915             :                 .name = discard_const_p(char, "MaxSa"),
    2916             :                 .get = py_DNS_ADDR_get_MaxSa,
    2917             :                 .set = py_DNS_ADDR_set_MaxSa,
    2918             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    2919             :         },
    2920             :         {
    2921             :                 .name = discard_const_p(char, "DnsAddrUserDword"),
    2922             :                 .get = py_DNS_ADDR_get_DnsAddrUserDword,
    2923             :                 .set = py_DNS_ADDR_set_DnsAddrUserDword,
    2924             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    2925             :         },
    2926             :         { .name = NULL }
    2927             : };
    2928             : 
    2929           0 : static PyObject *py_DNS_ADDR_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    2930             : {
    2931           0 :         return pytalloc_new(struct DNS_ADDR, type);
    2932             : }
    2933             : 
    2934             : 
    2935             : static PyTypeObject DNS_ADDR_Type = {
    2936             :         PyVarObject_HEAD_INIT(NULL, 0)
    2937             :         .tp_name = "dnsserver.DNS_ADDR",
    2938             :         .tp_getset = py_DNS_ADDR_getsetters,
    2939             :         .tp_methods = NULL,
    2940             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    2941             :         .tp_new = py_DNS_ADDR_new,
    2942             : };
    2943             : 
    2944             : 
    2945           0 : static PyObject *py_DNS_ADDR_ARRAY_get_MaxCount(PyObject *obj, void *closure)
    2946             : {
    2947           0 :         struct DNS_ADDR_ARRAY *object = pytalloc_get_ptr(obj);
    2948           0 :         PyObject *py_MaxCount;
    2949           0 :         py_MaxCount = PyLong_FromUnsignedLongLong((uint32_t)(object->MaxCount));
    2950           0 :         return py_MaxCount;
    2951             : }
    2952             : 
    2953           0 : static int py_DNS_ADDR_ARRAY_set_MaxCount(PyObject *py_obj, PyObject *value, void *closure)
    2954             : {
    2955           0 :         struct DNS_ADDR_ARRAY *object = pytalloc_get_ptr(py_obj);
    2956           0 :         if (value == NULL) {
    2957           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->MaxCount");
    2958           0 :                 return -1;
    2959             :         }
    2960             :         {
    2961           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->MaxCount));
    2962           0 :                 if (PyLong_Check(value)) {
    2963           0 :                         unsigned long long test_var;
    2964           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    2965           0 :                         if (PyErr_Occurred() != NULL) {
    2966           0 :                                 return -1;
    2967             :                         }
    2968           0 :                         if (test_var > uint_max) {
    2969           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    2970             :                                   PyLong_Type.tp_name, uint_max, test_var);
    2971           0 :                                 return -1;
    2972             :                         }
    2973           0 :                         object->MaxCount = test_var;
    2974             :                 } else {
    2975           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    2976             :                           PyLong_Type.tp_name);
    2977           0 :                         return -1;
    2978             :                 }
    2979             :         }
    2980           0 :         return 0;
    2981             : }
    2982             : 
    2983           2 : static PyObject *py_DNS_ADDR_ARRAY_get_AddrCount(PyObject *obj, void *closure)
    2984             : {
    2985           2 :         struct DNS_ADDR_ARRAY *object = pytalloc_get_ptr(obj);
    2986           0 :         PyObject *py_AddrCount;
    2987           2 :         py_AddrCount = PyLong_FromUnsignedLongLong((uint32_t)(object->AddrCount));
    2988           2 :         return py_AddrCount;
    2989             : }
    2990             : 
    2991           0 : static int py_DNS_ADDR_ARRAY_set_AddrCount(PyObject *py_obj, PyObject *value, void *closure)
    2992             : {
    2993           0 :         struct DNS_ADDR_ARRAY *object = pytalloc_get_ptr(py_obj);
    2994           0 :         if (value == NULL) {
    2995           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->AddrCount");
    2996           0 :                 return -1;
    2997             :         }
    2998             :         {
    2999           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->AddrCount));
    3000           0 :                 if (PyLong_Check(value)) {
    3001           0 :                         unsigned long long test_var;
    3002           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    3003           0 :                         if (PyErr_Occurred() != NULL) {
    3004           0 :                                 return -1;
    3005             :                         }
    3006           0 :                         if (test_var > uint_max) {
    3007           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3008             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3009           0 :                                 return -1;
    3010             :                         }
    3011           0 :                         object->AddrCount = test_var;
    3012             :                 } else {
    3013           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3014             :                           PyLong_Type.tp_name);
    3015           0 :                         return -1;
    3016             :                 }
    3017             :         }
    3018           0 :         return 0;
    3019             : }
    3020             : 
    3021           0 : static PyObject *py_DNS_ADDR_ARRAY_get_Tag(PyObject *obj, void *closure)
    3022             : {
    3023           0 :         struct DNS_ADDR_ARRAY *object = pytalloc_get_ptr(obj);
    3024           0 :         PyObject *py_Tag;
    3025           0 :         py_Tag = PyLong_FromUnsignedLongLong((uint32_t)(object->Tag));
    3026           0 :         return py_Tag;
    3027             : }
    3028             : 
    3029           0 : static int py_DNS_ADDR_ARRAY_set_Tag(PyObject *py_obj, PyObject *value, void *closure)
    3030             : {
    3031           0 :         struct DNS_ADDR_ARRAY *object = pytalloc_get_ptr(py_obj);
    3032           0 :         if (value == NULL) {
    3033           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->Tag");
    3034           0 :                 return -1;
    3035             :         }
    3036             :         {
    3037           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->Tag));
    3038           0 :                 if (PyLong_Check(value)) {
    3039           0 :                         unsigned long long test_var;
    3040           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    3041           0 :                         if (PyErr_Occurred() != NULL) {
    3042           0 :                                 return -1;
    3043             :                         }
    3044           0 :                         if (test_var > uint_max) {
    3045           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3046             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3047           0 :                                 return -1;
    3048             :                         }
    3049           0 :                         object->Tag = test_var;
    3050             :                 } else {
    3051           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3052             :                           PyLong_Type.tp_name);
    3053           0 :                         return -1;
    3054             :                 }
    3055             :         }
    3056           0 :         return 0;
    3057             : }
    3058             : 
    3059           0 : static PyObject *py_DNS_ADDR_ARRAY_get_Family(PyObject *obj, void *closure)
    3060             : {
    3061           0 :         struct DNS_ADDR_ARRAY *object = pytalloc_get_ptr(obj);
    3062           0 :         PyObject *py_Family;
    3063           0 :         py_Family = PyLong_FromLong((uint16_t)(object->Family));
    3064           0 :         return py_Family;
    3065             : }
    3066             : 
    3067           0 : static int py_DNS_ADDR_ARRAY_set_Family(PyObject *py_obj, PyObject *value, void *closure)
    3068             : {
    3069           0 :         struct DNS_ADDR_ARRAY *object = pytalloc_get_ptr(py_obj);
    3070           0 :         if (value == NULL) {
    3071           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->Family");
    3072           0 :                 return -1;
    3073             :         }
    3074             :         {
    3075           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->Family));
    3076           0 :                 if (PyLong_Check(value)) {
    3077           0 :                         unsigned long long test_var;
    3078           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    3079           0 :                         if (PyErr_Occurred() != NULL) {
    3080           0 :                                 return -1;
    3081             :                         }
    3082           0 :                         if (test_var > uint_max) {
    3083           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3084             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3085           0 :                                 return -1;
    3086             :                         }
    3087           0 :                         object->Family = test_var;
    3088             :                 } else {
    3089           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3090             :                           PyLong_Type.tp_name);
    3091           0 :                         return -1;
    3092             :                 }
    3093             :         }
    3094           0 :         return 0;
    3095             : }
    3096             : 
    3097           0 : static PyObject *py_DNS_ADDR_ARRAY_get_WordReserved(PyObject *obj, void *closure)
    3098             : {
    3099           0 :         struct DNS_ADDR_ARRAY *object = pytalloc_get_ptr(obj);
    3100           0 :         PyObject *py_WordReserved;
    3101           0 :         py_WordReserved = PyLong_FromLong((uint16_t)(object->WordReserved));
    3102           0 :         return py_WordReserved;
    3103             : }
    3104             : 
    3105           0 : static int py_DNS_ADDR_ARRAY_set_WordReserved(PyObject *py_obj, PyObject *value, void *closure)
    3106             : {
    3107           0 :         struct DNS_ADDR_ARRAY *object = pytalloc_get_ptr(py_obj);
    3108           0 :         if (value == NULL) {
    3109           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->WordReserved");
    3110           0 :                 return -1;
    3111             :         }
    3112             :         {
    3113           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->WordReserved));
    3114           0 :                 if (PyLong_Check(value)) {
    3115           0 :                         unsigned long long test_var;
    3116           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    3117           0 :                         if (PyErr_Occurred() != NULL) {
    3118           0 :                                 return -1;
    3119             :                         }
    3120           0 :                         if (test_var > uint_max) {
    3121           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3122             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3123           0 :                                 return -1;
    3124             :                         }
    3125           0 :                         object->WordReserved = test_var;
    3126             :                 } else {
    3127           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3128             :                           PyLong_Type.tp_name);
    3129           0 :                         return -1;
    3130             :                 }
    3131             :         }
    3132           0 :         return 0;
    3133             : }
    3134             : 
    3135           0 : static PyObject *py_DNS_ADDR_ARRAY_get_Flags(PyObject *obj, void *closure)
    3136             : {
    3137           0 :         struct DNS_ADDR_ARRAY *object = pytalloc_get_ptr(obj);
    3138           0 :         PyObject *py_Flags;
    3139           0 :         py_Flags = PyLong_FromUnsignedLongLong((uint32_t)(object->Flags));
    3140           0 :         return py_Flags;
    3141             : }
    3142             : 
    3143           0 : static int py_DNS_ADDR_ARRAY_set_Flags(PyObject *py_obj, PyObject *value, void *closure)
    3144             : {
    3145           0 :         struct DNS_ADDR_ARRAY *object = pytalloc_get_ptr(py_obj);
    3146           0 :         if (value == NULL) {
    3147           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->Flags");
    3148           0 :                 return -1;
    3149             :         }
    3150             :         {
    3151           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->Flags));
    3152           0 :                 if (PyLong_Check(value)) {
    3153           0 :                         unsigned long long test_var;
    3154           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    3155           0 :                         if (PyErr_Occurred() != NULL) {
    3156           0 :                                 return -1;
    3157             :                         }
    3158           0 :                         if (test_var > uint_max) {
    3159           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3160             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3161           0 :                                 return -1;
    3162             :                         }
    3163           0 :                         object->Flags = test_var;
    3164             :                 } else {
    3165           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3166             :                           PyLong_Type.tp_name);
    3167           0 :                         return -1;
    3168             :                 }
    3169             :         }
    3170           0 :         return 0;
    3171             : }
    3172             : 
    3173           0 : static PyObject *py_DNS_ADDR_ARRAY_get_MatchFlag(PyObject *obj, void *closure)
    3174             : {
    3175           0 :         struct DNS_ADDR_ARRAY *object = pytalloc_get_ptr(obj);
    3176           0 :         PyObject *py_MatchFlag;
    3177           0 :         py_MatchFlag = PyLong_FromUnsignedLongLong((uint32_t)(object->MatchFlag));
    3178           0 :         return py_MatchFlag;
    3179             : }
    3180             : 
    3181           0 : static int py_DNS_ADDR_ARRAY_set_MatchFlag(PyObject *py_obj, PyObject *value, void *closure)
    3182             : {
    3183           0 :         struct DNS_ADDR_ARRAY *object = pytalloc_get_ptr(py_obj);
    3184           0 :         if (value == NULL) {
    3185           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->MatchFlag");
    3186           0 :                 return -1;
    3187             :         }
    3188             :         {
    3189           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->MatchFlag));
    3190           0 :                 if (PyLong_Check(value)) {
    3191           0 :                         unsigned long long test_var;
    3192           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    3193           0 :                         if (PyErr_Occurred() != NULL) {
    3194           0 :                                 return -1;
    3195             :                         }
    3196           0 :                         if (test_var > uint_max) {
    3197           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3198             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3199           0 :                                 return -1;
    3200             :                         }
    3201           0 :                         object->MatchFlag = test_var;
    3202             :                 } else {
    3203           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3204             :                           PyLong_Type.tp_name);
    3205           0 :                         return -1;
    3206             :                 }
    3207             :         }
    3208           0 :         return 0;
    3209             : }
    3210             : 
    3211           0 : static PyObject *py_DNS_ADDR_ARRAY_get_Reserved1(PyObject *obj, void *closure)
    3212             : {
    3213           0 :         struct DNS_ADDR_ARRAY *object = pytalloc_get_ptr(obj);
    3214           0 :         PyObject *py_Reserved1;
    3215           0 :         py_Reserved1 = PyLong_FromUnsignedLongLong((uint32_t)(object->Reserved1));
    3216           0 :         return py_Reserved1;
    3217             : }
    3218             : 
    3219           0 : static int py_DNS_ADDR_ARRAY_set_Reserved1(PyObject *py_obj, PyObject *value, void *closure)
    3220             : {
    3221           0 :         struct DNS_ADDR_ARRAY *object = pytalloc_get_ptr(py_obj);
    3222           0 :         if (value == NULL) {
    3223           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->Reserved1");
    3224           0 :                 return -1;
    3225             :         }
    3226             :         {
    3227           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->Reserved1));
    3228           0 :                 if (PyLong_Check(value)) {
    3229           0 :                         unsigned long long test_var;
    3230           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    3231           0 :                         if (PyErr_Occurred() != NULL) {
    3232           0 :                                 return -1;
    3233             :                         }
    3234           0 :                         if (test_var > uint_max) {
    3235           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3236             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3237           0 :                                 return -1;
    3238             :                         }
    3239           0 :                         object->Reserved1 = test_var;
    3240             :                 } else {
    3241           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3242             :                           PyLong_Type.tp_name);
    3243           0 :                         return -1;
    3244             :                 }
    3245             :         }
    3246           0 :         return 0;
    3247             : }
    3248             : 
    3249           0 : static PyObject *py_DNS_ADDR_ARRAY_get_Reserved2(PyObject *obj, void *closure)
    3250             : {
    3251           0 :         struct DNS_ADDR_ARRAY *object = pytalloc_get_ptr(obj);
    3252           0 :         PyObject *py_Reserved2;
    3253           0 :         py_Reserved2 = PyLong_FromUnsignedLongLong((uint32_t)(object->Reserved2));
    3254           0 :         return py_Reserved2;
    3255             : }
    3256             : 
    3257           0 : static int py_DNS_ADDR_ARRAY_set_Reserved2(PyObject *py_obj, PyObject *value, void *closure)
    3258             : {
    3259           0 :         struct DNS_ADDR_ARRAY *object = pytalloc_get_ptr(py_obj);
    3260           0 :         if (value == NULL) {
    3261           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->Reserved2");
    3262           0 :                 return -1;
    3263             :         }
    3264             :         {
    3265           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->Reserved2));
    3266           0 :                 if (PyLong_Check(value)) {
    3267           0 :                         unsigned long long test_var;
    3268           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    3269           0 :                         if (PyErr_Occurred() != NULL) {
    3270           0 :                                 return -1;
    3271             :                         }
    3272           0 :                         if (test_var > uint_max) {
    3273           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3274             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3275           0 :                                 return -1;
    3276             :                         }
    3277           0 :                         object->Reserved2 = test_var;
    3278             :                 } else {
    3279           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3280             :                           PyLong_Type.tp_name);
    3281           0 :                         return -1;
    3282             :                 }
    3283             :         }
    3284           0 :         return 0;
    3285             : }
    3286             : 
    3287          10 : static PyObject *py_DNS_ADDR_ARRAY_get_AddrArray(PyObject *obj, void *closure)
    3288             : {
    3289          10 :         struct DNS_ADDR_ARRAY *object = pytalloc_get_ptr(obj);
    3290           0 :         PyObject *py_AddrArray;
    3291          10 :         py_AddrArray = PyList_New(object->AddrCount);
    3292          10 :         if (py_AddrArray == NULL) {
    3293           0 :                 return NULL;
    3294             :         }
    3295             :         {
    3296             :                 int AddrArray_cntr_0;
    3297          30 :                 for (AddrArray_cntr_0 = 0; AddrArray_cntr_0 < (object->AddrCount); AddrArray_cntr_0++) {
    3298           0 :                         PyObject *py_AddrArray_0;
    3299          20 :                         py_AddrArray_0 = pytalloc_reference_ex(&DNS_ADDR_Type, object->AddrArray, &(object->AddrArray)[AddrArray_cntr_0]);
    3300          20 :                         PyList_SetItem(py_AddrArray, AddrArray_cntr_0, py_AddrArray_0);
    3301             :                 }
    3302             :         }
    3303          10 :         return py_AddrArray;
    3304             : }
    3305             : 
    3306           0 : static int py_DNS_ADDR_ARRAY_set_AddrArray(PyObject *py_obj, PyObject *value, void *closure)
    3307             : {
    3308           0 :         struct DNS_ADDR_ARRAY *object = pytalloc_get_ptr(py_obj);
    3309           0 :         if (value == NULL) {
    3310           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->AddrArray");
    3311           0 :                 return -1;
    3312             :         }
    3313           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
    3314             :         {
    3315           0 :                 int AddrArray_cntr_0;
    3316           0 :                 object->AddrArray = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->AddrArray, PyList_GET_SIZE(value));
    3317           0 :                 if (!object->AddrArray) { return -1; }
    3318           0 :                 talloc_set_name_const(object->AddrArray, "ARRAY: object->AddrArray");
    3319           0 :                 for (AddrArray_cntr_0 = 0; AddrArray_cntr_0 < PyList_GET_SIZE(value); AddrArray_cntr_0++) {
    3320           0 :                         if (PyList_GET_ITEM(value, AddrArray_cntr_0) == NULL) {
    3321           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->AddrArray)[AddrArray_cntr_0]");
    3322           0 :                                 return -1;
    3323             :                         }
    3324           0 :                         PY_CHECK_TYPE(&DNS_ADDR_Type, PyList_GET_ITEM(value, AddrArray_cntr_0), return -1;);
    3325           0 :                         if (talloc_reference(object->AddrArray, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, AddrArray_cntr_0))) == NULL) {
    3326           0 :                                 PyErr_NoMemory();
    3327           0 :                                 return -1;
    3328             :                         }
    3329           0 :                         (object->AddrArray)[AddrArray_cntr_0] = *(struct DNS_ADDR *)pytalloc_get_ptr(PyList_GET_ITEM(value, AddrArray_cntr_0));
    3330             :                 }
    3331             :         }
    3332           0 :         return 0;
    3333             : }
    3334             : 
    3335             : static PyGetSetDef py_DNS_ADDR_ARRAY_getsetters[] = {
    3336             :         {
    3337             :                 .name = discard_const_p(char, "MaxCount"),
    3338             :                 .get = py_DNS_ADDR_ARRAY_get_MaxCount,
    3339             :                 .set = py_DNS_ADDR_ARRAY_set_MaxCount,
    3340             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    3341             :         },
    3342             :         {
    3343             :                 .name = discard_const_p(char, "AddrCount"),
    3344             :                 .get = py_DNS_ADDR_ARRAY_get_AddrCount,
    3345             :                 .set = py_DNS_ADDR_ARRAY_set_AddrCount,
    3346             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    3347             :         },
    3348             :         {
    3349             :                 .name = discard_const_p(char, "Tag"),
    3350             :                 .get = py_DNS_ADDR_ARRAY_get_Tag,
    3351             :                 .set = py_DNS_ADDR_ARRAY_set_Tag,
    3352             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    3353             :         },
    3354             :         {
    3355             :                 .name = discard_const_p(char, "Family"),
    3356             :                 .get = py_DNS_ADDR_ARRAY_get_Family,
    3357             :                 .set = py_DNS_ADDR_ARRAY_set_Family,
    3358             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
    3359             :         },
    3360             :         {
    3361             :                 .name = discard_const_p(char, "WordReserved"),
    3362             :                 .get = py_DNS_ADDR_ARRAY_get_WordReserved,
    3363             :                 .set = py_DNS_ADDR_ARRAY_set_WordReserved,
    3364             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
    3365             :         },
    3366             :         {
    3367             :                 .name = discard_const_p(char, "Flags"),
    3368             :                 .get = py_DNS_ADDR_ARRAY_get_Flags,
    3369             :                 .set = py_DNS_ADDR_ARRAY_set_Flags,
    3370             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    3371             :         },
    3372             :         {
    3373             :                 .name = discard_const_p(char, "MatchFlag"),
    3374             :                 .get = py_DNS_ADDR_ARRAY_get_MatchFlag,
    3375             :                 .set = py_DNS_ADDR_ARRAY_set_MatchFlag,
    3376             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    3377             :         },
    3378             :         {
    3379             :                 .name = discard_const_p(char, "Reserved1"),
    3380             :                 .get = py_DNS_ADDR_ARRAY_get_Reserved1,
    3381             :                 .set = py_DNS_ADDR_ARRAY_set_Reserved1,
    3382             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    3383             :         },
    3384             :         {
    3385             :                 .name = discard_const_p(char, "Reserved2"),
    3386             :                 .get = py_DNS_ADDR_ARRAY_get_Reserved2,
    3387             :                 .set = py_DNS_ADDR_ARRAY_set_Reserved2,
    3388             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    3389             :         },
    3390             :         {
    3391             :                 .name = discard_const_p(char, "AddrArray"),
    3392             :                 .get = py_DNS_ADDR_ARRAY_get_AddrArray,
    3393             :                 .set = py_DNS_ADDR_ARRAY_set_AddrArray,
    3394             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ADDR")
    3395             :         },
    3396             :         { .name = NULL }
    3397             : };
    3398             : 
    3399           0 : static PyObject *py_DNS_ADDR_ARRAY_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    3400             : {
    3401           0 :         return pytalloc_new(struct DNS_ADDR_ARRAY, type);
    3402             : }
    3403             : 
    3404             : 
    3405             : static PyTypeObject DNS_ADDR_ARRAY_Type = {
    3406             :         PyVarObject_HEAD_INIT(NULL, 0)
    3407             :         .tp_name = "dnsserver.DNS_ADDR_ARRAY",
    3408             :         .tp_getset = py_DNS_ADDR_ARRAY_getsetters,
    3409             :         .tp_methods = NULL,
    3410             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    3411             :         .tp_new = py_DNS_ADDR_ARRAY_new,
    3412             : };
    3413             : 
    3414             : 
    3415           0 : static PyObject *py_DNS_RPC_IP_VALIDATE_get_dwRpcStructureVersion(PyObject *obj, void *closure)
    3416             : {
    3417           0 :         struct DNS_RPC_IP_VALIDATE *object = pytalloc_get_ptr(obj);
    3418           0 :         PyObject *py_dwRpcStructureVersion;
    3419           0 :         py_dwRpcStructureVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcStructureVersion));
    3420           0 :         return py_dwRpcStructureVersion;
    3421             : }
    3422             : 
    3423           0 : static int py_DNS_RPC_IP_VALIDATE_set_dwRpcStructureVersion(PyObject *py_obj, PyObject *value, void *closure)
    3424             : {
    3425           0 :         struct DNS_RPC_IP_VALIDATE *object = pytalloc_get_ptr(py_obj);
    3426           0 :         if (value == NULL) {
    3427           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcStructureVersion");
    3428           0 :                 return -1;
    3429             :         }
    3430             :         {
    3431           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcStructureVersion));
    3432           0 :                 if (PyLong_Check(value)) {
    3433           0 :                         unsigned long long test_var;
    3434           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    3435           0 :                         if (PyErr_Occurred() != NULL) {
    3436           0 :                                 return -1;
    3437             :                         }
    3438           0 :                         if (test_var > uint_max) {
    3439           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3440             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3441           0 :                                 return -1;
    3442             :                         }
    3443           0 :                         object->dwRpcStructureVersion = test_var;
    3444             :                 } else {
    3445           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3446             :                           PyLong_Type.tp_name);
    3447           0 :                         return -1;
    3448             :                 }
    3449             :         }
    3450           0 :         return 0;
    3451             : }
    3452             : 
    3453           0 : static PyObject *py_DNS_RPC_IP_VALIDATE_get_dwReserved0(PyObject *obj, void *closure)
    3454             : {
    3455           0 :         struct DNS_RPC_IP_VALIDATE *object = pytalloc_get_ptr(obj);
    3456           0 :         PyObject *py_dwReserved0;
    3457           0 :         py_dwReserved0 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved0));
    3458           0 :         return py_dwReserved0;
    3459             : }
    3460             : 
    3461           0 : static int py_DNS_RPC_IP_VALIDATE_set_dwReserved0(PyObject *py_obj, PyObject *value, void *closure)
    3462             : {
    3463           0 :         struct DNS_RPC_IP_VALIDATE *object = pytalloc_get_ptr(py_obj);
    3464           0 :         if (value == NULL) {
    3465           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved0");
    3466           0 :                 return -1;
    3467             :         }
    3468             :         {
    3469           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved0));
    3470           0 :                 if (PyLong_Check(value)) {
    3471           0 :                         unsigned long long test_var;
    3472           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    3473           0 :                         if (PyErr_Occurred() != NULL) {
    3474           0 :                                 return -1;
    3475             :                         }
    3476           0 :                         if (test_var > uint_max) {
    3477           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3478             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3479           0 :                                 return -1;
    3480             :                         }
    3481           0 :                         object->dwReserved0 = test_var;
    3482             :                 } else {
    3483           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3484             :                           PyLong_Type.tp_name);
    3485           0 :                         return -1;
    3486             :                 }
    3487             :         }
    3488           0 :         return 0;
    3489             : }
    3490             : 
    3491           0 : static PyObject *py_DNS_RPC_IP_VALIDATE_get_dwContext(PyObject *obj, void *closure)
    3492             : {
    3493           0 :         struct DNS_RPC_IP_VALIDATE *object = pytalloc_get_ptr(obj);
    3494           0 :         PyObject *py_dwContext;
    3495           0 :         py_dwContext = PyLong_FromUnsignedLongLong((uint32_t)(object->dwContext));
    3496           0 :         return py_dwContext;
    3497             : }
    3498             : 
    3499           0 : static int py_DNS_RPC_IP_VALIDATE_set_dwContext(PyObject *py_obj, PyObject *value, void *closure)
    3500             : {
    3501           0 :         struct DNS_RPC_IP_VALIDATE *object = pytalloc_get_ptr(py_obj);
    3502           0 :         if (value == NULL) {
    3503           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwContext");
    3504           0 :                 return -1;
    3505             :         }
    3506             :         {
    3507           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwContext));
    3508           0 :                 if (PyLong_Check(value)) {
    3509           0 :                         unsigned long long test_var;
    3510           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    3511           0 :                         if (PyErr_Occurred() != NULL) {
    3512           0 :                                 return -1;
    3513             :                         }
    3514           0 :                         if (test_var > uint_max) {
    3515           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3516             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3517           0 :                                 return -1;
    3518             :                         }
    3519           0 :                         object->dwContext = test_var;
    3520             :                 } else {
    3521           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3522             :                           PyLong_Type.tp_name);
    3523           0 :                         return -1;
    3524             :                 }
    3525             :         }
    3526           0 :         return 0;
    3527             : }
    3528             : 
    3529           0 : static PyObject *py_DNS_RPC_IP_VALIDATE_get_dwReserved1(PyObject *obj, void *closure)
    3530             : {
    3531           0 :         struct DNS_RPC_IP_VALIDATE *object = pytalloc_get_ptr(obj);
    3532           0 :         PyObject *py_dwReserved1;
    3533           0 :         py_dwReserved1 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved1));
    3534           0 :         return py_dwReserved1;
    3535             : }
    3536             : 
    3537           0 : static int py_DNS_RPC_IP_VALIDATE_set_dwReserved1(PyObject *py_obj, PyObject *value, void *closure)
    3538             : {
    3539           0 :         struct DNS_RPC_IP_VALIDATE *object = pytalloc_get_ptr(py_obj);
    3540           0 :         if (value == NULL) {
    3541           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved1");
    3542           0 :                 return -1;
    3543             :         }
    3544             :         {
    3545           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved1));
    3546           0 :                 if (PyLong_Check(value)) {
    3547           0 :                         unsigned long long test_var;
    3548           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    3549           0 :                         if (PyErr_Occurred() != NULL) {
    3550           0 :                                 return -1;
    3551             :                         }
    3552           0 :                         if (test_var > uint_max) {
    3553           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3554             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3555           0 :                                 return -1;
    3556             :                         }
    3557           0 :                         object->dwReserved1 = test_var;
    3558             :                 } else {
    3559           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3560             :                           PyLong_Type.tp_name);
    3561           0 :                         return -1;
    3562             :                 }
    3563             :         }
    3564           0 :         return 0;
    3565             : }
    3566             : 
    3567           0 : static PyObject *py_DNS_RPC_IP_VALIDATE_get_pszContextName(PyObject *obj, void *closure)
    3568             : {
    3569           0 :         struct DNS_RPC_IP_VALIDATE *object = pytalloc_get_ptr(obj);
    3570           0 :         PyObject *py_pszContextName;
    3571           0 :         if (object->pszContextName == NULL) {
    3572           0 :                 Py_RETURN_NONE;
    3573             :         }
    3574           0 :         if (object->pszContextName == NULL) {
    3575           0 :                 py_pszContextName = Py_None;
    3576           0 :                 Py_INCREF(py_pszContextName);
    3577             :         } else {
    3578           0 :                 if (object->pszContextName == NULL) {
    3579           0 :                         py_pszContextName = Py_None;
    3580           0 :                         Py_INCREF(py_pszContextName);
    3581             :                 } else {
    3582           0 :                         py_pszContextName = PyUnicode_Decode(object->pszContextName, strlen(object->pszContextName), "utf-8", "ignore");
    3583             :                 }
    3584             :         }
    3585           0 :         return py_pszContextName;
    3586             : }
    3587             : 
    3588           0 : static int py_DNS_RPC_IP_VALIDATE_set_pszContextName(PyObject *py_obj, PyObject *value, void *closure)
    3589             : {
    3590           0 :         struct DNS_RPC_IP_VALIDATE *object = pytalloc_get_ptr(py_obj);
    3591           0 :         if (value == NULL) {
    3592           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszContextName");
    3593           0 :                 return -1;
    3594             :         }
    3595           0 :         if (value == Py_None) {
    3596           0 :                 object->pszContextName = NULL;
    3597             :         } else {
    3598           0 :                 object->pszContextName = NULL;
    3599             :                 {
    3600           0 :                         const char *test_str;
    3601           0 :                         const char *talloc_str;
    3602           0 :                         PyObject *unicode = NULL;
    3603           0 :                         if (PyUnicode_Check(value)) {
    3604           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    3605           0 :                                 if (unicode == NULL) {
    3606           0 :                                         return -1;
    3607             :                                 }
    3608           0 :                                 test_str = PyBytes_AS_STRING(unicode);
    3609           0 :                         } else if (PyBytes_Check(value)) {
    3610           0 :                                 test_str = PyBytes_AS_STRING(value);
    3611             :                         } else {
    3612           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    3613           0 :                                 return -1;
    3614             :                         }
    3615           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    3616           0 :                         if (unicode != NULL) {
    3617           0 :                                 Py_DECREF(unicode);
    3618             :                         }
    3619           0 :                         if (talloc_str == NULL) {
    3620           0 :                                 PyErr_NoMemory();
    3621           0 :                                 return -1;
    3622             :                         }
    3623           0 :                         object->pszContextName = talloc_str;
    3624             :                 }
    3625             :         }
    3626           0 :         return 0;
    3627             : }
    3628             : 
    3629           0 : static PyObject *py_DNS_RPC_IP_VALIDATE_get_aipValidateAddrs(PyObject *obj, void *closure)
    3630             : {
    3631           0 :         struct DNS_RPC_IP_VALIDATE *object = pytalloc_get_ptr(obj);
    3632           0 :         PyObject *py_aipValidateAddrs;
    3633           0 :         if (object->aipValidateAddrs == NULL) {
    3634           0 :                 Py_RETURN_NONE;
    3635             :         }
    3636           0 :         if (object->aipValidateAddrs == NULL) {
    3637           0 :                 py_aipValidateAddrs = Py_None;
    3638           0 :                 Py_INCREF(py_aipValidateAddrs);
    3639             :         } else {
    3640           0 :                 py_aipValidateAddrs = pytalloc_reference_ex(&DNS_ADDR_ARRAY_Type, object->aipValidateAddrs, object->aipValidateAddrs);
    3641             :         }
    3642           0 :         return py_aipValidateAddrs;
    3643             : }
    3644             : 
    3645           0 : static int py_DNS_RPC_IP_VALIDATE_set_aipValidateAddrs(PyObject *py_obj, PyObject *value, void *closure)
    3646             : {
    3647           0 :         struct DNS_RPC_IP_VALIDATE *object = pytalloc_get_ptr(py_obj);
    3648           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipValidateAddrs));
    3649           0 :         if (value == NULL) {
    3650           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipValidateAddrs");
    3651           0 :                 return -1;
    3652             :         }
    3653           0 :         if (value == Py_None) {
    3654           0 :                 object->aipValidateAddrs = NULL;
    3655             :         } else {
    3656           0 :                 object->aipValidateAddrs = NULL;
    3657           0 :                 PY_CHECK_TYPE(&DNS_ADDR_ARRAY_Type, value, return -1;);
    3658           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    3659           0 :                         PyErr_NoMemory();
    3660           0 :                         return -1;
    3661             :                 }
    3662           0 :                 object->aipValidateAddrs = (struct DNS_ADDR_ARRAY *)pytalloc_get_ptr(value);
    3663             :         }
    3664           0 :         return 0;
    3665             : }
    3666             : 
    3667             : static PyGetSetDef py_DNS_RPC_IP_VALIDATE_getsetters[] = {
    3668             :         {
    3669             :                 .name = discard_const_p(char, "dwRpcStructureVersion"),
    3670             :                 .get = py_DNS_RPC_IP_VALIDATE_get_dwRpcStructureVersion,
    3671             :                 .set = py_DNS_RPC_IP_VALIDATE_set_dwRpcStructureVersion,
    3672             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    3673             :         },
    3674             :         {
    3675             :                 .name = discard_const_p(char, "dwReserved0"),
    3676             :                 .get = py_DNS_RPC_IP_VALIDATE_get_dwReserved0,
    3677             :                 .set = py_DNS_RPC_IP_VALIDATE_set_dwReserved0,
    3678             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    3679             :         },
    3680             :         {
    3681             :                 .name = discard_const_p(char, "dwContext"),
    3682             :                 .get = py_DNS_RPC_IP_VALIDATE_get_dwContext,
    3683             :                 .set = py_DNS_RPC_IP_VALIDATE_set_dwContext,
    3684             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    3685             :         },
    3686             :         {
    3687             :                 .name = discard_const_p(char, "dwReserved1"),
    3688             :                 .get = py_DNS_RPC_IP_VALIDATE_get_dwReserved1,
    3689             :                 .set = py_DNS_RPC_IP_VALIDATE_set_dwReserved1,
    3690             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    3691             :         },
    3692             :         {
    3693             :                 .name = discard_const_p(char, "pszContextName"),
    3694             :                 .get = py_DNS_RPC_IP_VALIDATE_get_pszContextName,
    3695             :                 .set = py_DNS_RPC_IP_VALIDATE_set_pszContextName,
    3696             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    3697             :         },
    3698             :         {
    3699             :                 .name = discard_const_p(char, "aipValidateAddrs"),
    3700             :                 .get = py_DNS_RPC_IP_VALIDATE_get_aipValidateAddrs,
    3701             :                 .set = py_DNS_RPC_IP_VALIDATE_set_aipValidateAddrs,
    3702             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ADDR_ARRAY")
    3703             :         },
    3704             :         { .name = NULL }
    3705             : };
    3706             : 
    3707           0 : static PyObject *py_DNS_RPC_IP_VALIDATE_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    3708             : {
    3709           0 :         return pytalloc_new(struct DNS_RPC_IP_VALIDATE, type);
    3710             : }
    3711             : 
    3712             : 
    3713             : static PyTypeObject DNS_RPC_IP_VALIDATE_Type = {
    3714             :         PyVarObject_HEAD_INIT(NULL, 0)
    3715             :         .tp_name = "dnsserver.DNS_RPC_IP_VALIDATE",
    3716             :         .tp_getset = py_DNS_RPC_IP_VALIDATE_getsetters,
    3717             :         .tp_methods = NULL,
    3718             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    3719             :         .tp_new = py_DNS_RPC_IP_VALIDATE_new,
    3720             : };
    3721             : 
    3722             : 
    3723           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_dwVersion(PyObject *obj, void *closure)
    3724             : {
    3725           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    3726           0 :         PyObject *py_dwVersion;
    3727           1 :         py_dwVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwVersion));
    3728           1 :         return py_dwVersion;
    3729             : }
    3730             : 
    3731           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_dwVersion(PyObject *py_obj, PyObject *value, void *closure)
    3732             : {
    3733           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    3734           0 :         if (value == NULL) {
    3735           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwVersion");
    3736           0 :                 return -1;
    3737             :         }
    3738             :         {
    3739           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwVersion));
    3740           0 :                 if (PyLong_Check(value)) {
    3741           0 :                         unsigned long long test_var;
    3742           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    3743           0 :                         if (PyErr_Occurred() != NULL) {
    3744           0 :                                 return -1;
    3745             :                         }
    3746           0 :                         if (test_var > uint_max) {
    3747           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3748             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3749           0 :                                 return -1;
    3750             :                         }
    3751           0 :                         object->dwVersion = test_var;
    3752             :                 } else {
    3753           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3754             :                           PyLong_Type.tp_name);
    3755           0 :                         return -1;
    3756             :                 }
    3757             :         }
    3758           0 :         return 0;
    3759             : }
    3760             : 
    3761           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_fBootMethod(PyObject *obj, void *closure)
    3762             : {
    3763           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    3764           0 :         PyObject *py_fBootMethod;
    3765           1 :         py_fBootMethod = PyLong_FromLong((uint16_t)(object->fBootMethod));
    3766           1 :         return py_fBootMethod;
    3767             : }
    3768             : 
    3769           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_fBootMethod(PyObject *py_obj, PyObject *value, void *closure)
    3770             : {
    3771           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    3772           0 :         if (value == NULL) {
    3773           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fBootMethod");
    3774           0 :                 return -1;
    3775             :         }
    3776             :         {
    3777           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fBootMethod));
    3778           0 :                 if (PyLong_Check(value)) {
    3779           0 :                         unsigned long long test_var;
    3780           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    3781           0 :                         if (PyErr_Occurred() != NULL) {
    3782           0 :                                 return -1;
    3783             :                         }
    3784           0 :                         if (test_var > uint_max) {
    3785           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3786             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3787           0 :                                 return -1;
    3788             :                         }
    3789           0 :                         object->fBootMethod = test_var;
    3790             :                 } else {
    3791           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3792             :                           PyLong_Type.tp_name);
    3793           0 :                         return -1;
    3794             :                 }
    3795             :         }
    3796           0 :         return 0;
    3797             : }
    3798             : 
    3799           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_fAdminConfigured(PyObject *obj, void *closure)
    3800             : {
    3801           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    3802           0 :         PyObject *py_fAdminConfigured;
    3803           1 :         py_fAdminConfigured = PyLong_FromLong((uint16_t)(object->fAdminConfigured));
    3804           1 :         return py_fAdminConfigured;
    3805             : }
    3806             : 
    3807           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_fAdminConfigured(PyObject *py_obj, PyObject *value, void *closure)
    3808             : {
    3809           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    3810           0 :         if (value == NULL) {
    3811           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAdminConfigured");
    3812           0 :                 return -1;
    3813             :         }
    3814             :         {
    3815           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAdminConfigured));
    3816           0 :                 if (PyLong_Check(value)) {
    3817           0 :                         unsigned long long test_var;
    3818           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    3819           0 :                         if (PyErr_Occurred() != NULL) {
    3820           0 :                                 return -1;
    3821             :                         }
    3822           0 :                         if (test_var > uint_max) {
    3823           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3824             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3825           0 :                                 return -1;
    3826             :                         }
    3827           0 :                         object->fAdminConfigured = test_var;
    3828             :                 } else {
    3829           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3830             :                           PyLong_Type.tp_name);
    3831           0 :                         return -1;
    3832             :                 }
    3833             :         }
    3834           0 :         return 0;
    3835             : }
    3836             : 
    3837           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_fAllowUpdate(PyObject *obj, void *closure)
    3838             : {
    3839           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    3840           0 :         PyObject *py_fAllowUpdate;
    3841           1 :         py_fAllowUpdate = PyLong_FromLong((uint16_t)(object->fAllowUpdate));
    3842           1 :         return py_fAllowUpdate;
    3843             : }
    3844             : 
    3845           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_fAllowUpdate(PyObject *py_obj, PyObject *value, void *closure)
    3846             : {
    3847           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    3848           0 :         if (value == NULL) {
    3849           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAllowUpdate");
    3850           0 :                 return -1;
    3851             :         }
    3852             :         {
    3853           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAllowUpdate));
    3854           0 :                 if (PyLong_Check(value)) {
    3855           0 :                         unsigned long long test_var;
    3856           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    3857           0 :                         if (PyErr_Occurred() != NULL) {
    3858           0 :                                 return -1;
    3859             :                         }
    3860           0 :                         if (test_var > uint_max) {
    3861           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3862             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3863           0 :                                 return -1;
    3864             :                         }
    3865           0 :                         object->fAllowUpdate = test_var;
    3866             :                 } else {
    3867           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3868             :                           PyLong_Type.tp_name);
    3869           0 :                         return -1;
    3870             :                 }
    3871             :         }
    3872           0 :         return 0;
    3873             : }
    3874             : 
    3875           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_fDsAvailable(PyObject *obj, void *closure)
    3876             : {
    3877           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    3878           0 :         PyObject *py_fDsAvailable;
    3879           1 :         py_fDsAvailable = PyLong_FromLong((uint16_t)(object->fDsAvailable));
    3880           1 :         return py_fDsAvailable;
    3881             : }
    3882             : 
    3883           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_fDsAvailable(PyObject *py_obj, PyObject *value, void *closure)
    3884             : {
    3885           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    3886           0 :         if (value == NULL) {
    3887           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fDsAvailable");
    3888           0 :                 return -1;
    3889             :         }
    3890             :         {
    3891           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fDsAvailable));
    3892           0 :                 if (PyLong_Check(value)) {
    3893           0 :                         unsigned long long test_var;
    3894           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    3895           0 :                         if (PyErr_Occurred() != NULL) {
    3896           0 :                                 return -1;
    3897             :                         }
    3898           0 :                         if (test_var > uint_max) {
    3899           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    3900             :                                   PyLong_Type.tp_name, uint_max, test_var);
    3901           0 :                                 return -1;
    3902             :                         }
    3903           0 :                         object->fDsAvailable = test_var;
    3904             :                 } else {
    3905           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    3906             :                           PyLong_Type.tp_name);
    3907           0 :                         return -1;
    3908             :                 }
    3909             :         }
    3910           0 :         return 0;
    3911             : }
    3912             : 
    3913           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_pszServerName(PyObject *obj, void *closure)
    3914             : {
    3915           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    3916           0 :         PyObject *py_pszServerName;
    3917           1 :         if (object->pszServerName == NULL) {
    3918           0 :                 Py_RETURN_NONE;
    3919             :         }
    3920           1 :         if (object->pszServerName == NULL) {
    3921           0 :                 py_pszServerName = Py_None;
    3922           0 :                 Py_INCREF(py_pszServerName);
    3923             :         } else {
    3924           1 :                 if (object->pszServerName == NULL) {
    3925           0 :                         py_pszServerName = Py_None;
    3926           0 :                         Py_INCREF(py_pszServerName);
    3927             :                 } else {
    3928           1 :                         py_pszServerName = PyUnicode_Decode(object->pszServerName, strlen(object->pszServerName), "utf-8", "ignore");
    3929             :                 }
    3930             :         }
    3931           1 :         return py_pszServerName;
    3932             : }
    3933             : 
    3934           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_pszServerName(PyObject *py_obj, PyObject *value, void *closure)
    3935             : {
    3936           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    3937           0 :         if (value == NULL) {
    3938           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszServerName");
    3939           0 :                 return -1;
    3940             :         }
    3941           0 :         if (value == Py_None) {
    3942           0 :                 object->pszServerName = NULL;
    3943             :         } else {
    3944           0 :                 object->pszServerName = NULL;
    3945             :                 {
    3946           0 :                         const char *test_str;
    3947           0 :                         const char *talloc_str;
    3948           0 :                         PyObject *unicode = NULL;
    3949           0 :                         if (PyUnicode_Check(value)) {
    3950           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    3951           0 :                                 if (unicode == NULL) {
    3952           0 :                                         return -1;
    3953             :                                 }
    3954           0 :                                 test_str = PyBytes_AS_STRING(unicode);
    3955           0 :                         } else if (PyBytes_Check(value)) {
    3956           0 :                                 test_str = PyBytes_AS_STRING(value);
    3957             :                         } else {
    3958           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    3959           0 :                                 return -1;
    3960             :                         }
    3961           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    3962           0 :                         if (unicode != NULL) {
    3963           0 :                                 Py_DECREF(unicode);
    3964             :                         }
    3965           0 :                         if (talloc_str == NULL) {
    3966           0 :                                 PyErr_NoMemory();
    3967           0 :                                 return -1;
    3968             :                         }
    3969           0 :                         object->pszServerName = talloc_str;
    3970             :                 }
    3971             :         }
    3972           0 :         return 0;
    3973             : }
    3974             : 
    3975           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_pszDsContainer(PyObject *obj, void *closure)
    3976             : {
    3977           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    3978           0 :         PyObject *py_pszDsContainer;
    3979           1 :         if (object->pszDsContainer == NULL) {
    3980           0 :                 Py_RETURN_NONE;
    3981             :         }
    3982           1 :         if (object->pszDsContainer == NULL) {
    3983           0 :                 py_pszDsContainer = Py_None;
    3984           0 :                 Py_INCREF(py_pszDsContainer);
    3985             :         } else {
    3986           1 :                 if (object->pszDsContainer == NULL) {
    3987           0 :                         py_pszDsContainer = Py_None;
    3988           0 :                         Py_INCREF(py_pszDsContainer);
    3989             :                 } else {
    3990           1 :                         py_pszDsContainer = PyUnicode_Decode(object->pszDsContainer, strlen(object->pszDsContainer), "utf-8", "ignore");
    3991             :                 }
    3992             :         }
    3993           1 :         return py_pszDsContainer;
    3994             : }
    3995             : 
    3996           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_pszDsContainer(PyObject *py_obj, PyObject *value, void *closure)
    3997             : {
    3998           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    3999           0 :         if (value == NULL) {
    4000           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszDsContainer");
    4001           0 :                 return -1;
    4002             :         }
    4003           0 :         if (value == Py_None) {
    4004           0 :                 object->pszDsContainer = NULL;
    4005             :         } else {
    4006           0 :                 object->pszDsContainer = NULL;
    4007             :                 {
    4008           0 :                         const char *test_str;
    4009           0 :                         const char *talloc_str;
    4010           0 :                         PyObject *unicode = NULL;
    4011           0 :                         if (PyUnicode_Check(value)) {
    4012           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    4013           0 :                                 if (unicode == NULL) {
    4014           0 :                                         return -1;
    4015             :                                 }
    4016           0 :                                 test_str = PyBytes_AS_STRING(unicode);
    4017           0 :                         } else if (PyBytes_Check(value)) {
    4018           0 :                                 test_str = PyBytes_AS_STRING(value);
    4019             :                         } else {
    4020           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    4021           0 :                                 return -1;
    4022             :                         }
    4023           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    4024           0 :                         if (unicode != NULL) {
    4025           0 :                                 Py_DECREF(unicode);
    4026             :                         }
    4027           0 :                         if (talloc_str == NULL) {
    4028           0 :                                 PyErr_NoMemory();
    4029           0 :                                 return -1;
    4030             :                         }
    4031           0 :                         object->pszDsContainer = talloc_str;
    4032             :                 }
    4033             :         }
    4034           0 :         return 0;
    4035             : }
    4036             : 
    4037           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_aipServerAddrs(PyObject *obj, void *closure)
    4038             : {
    4039           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    4040           0 :         PyObject *py_aipServerAddrs;
    4041           1 :         if (object->aipServerAddrs == NULL) {
    4042           0 :                 Py_RETURN_NONE;
    4043             :         }
    4044           1 :         if (object->aipServerAddrs == NULL) {
    4045           0 :                 py_aipServerAddrs = Py_None;
    4046           0 :                 Py_INCREF(py_aipServerAddrs);
    4047             :         } else {
    4048           1 :                 py_aipServerAddrs = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipServerAddrs, object->aipServerAddrs);
    4049             :         }
    4050           1 :         return py_aipServerAddrs;
    4051             : }
    4052             : 
    4053           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_aipServerAddrs(PyObject *py_obj, PyObject *value, void *closure)
    4054             : {
    4055           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    4056           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipServerAddrs));
    4057           0 :         if (value == NULL) {
    4058           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipServerAddrs");
    4059           0 :                 return -1;
    4060             :         }
    4061           0 :         if (value == Py_None) {
    4062           0 :                 object->aipServerAddrs = NULL;
    4063             :         } else {
    4064           0 :                 object->aipServerAddrs = NULL;
    4065           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
    4066           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    4067           0 :                         PyErr_NoMemory();
    4068           0 :                         return -1;
    4069             :                 }
    4070           0 :                 object->aipServerAddrs = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
    4071             :         }
    4072           0 :         return 0;
    4073             : }
    4074             : 
    4075           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_aipListenAddrs(PyObject *obj, void *closure)
    4076             : {
    4077           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    4078           0 :         PyObject *py_aipListenAddrs;
    4079           1 :         if (object->aipListenAddrs == NULL) {
    4080           0 :                 Py_RETURN_NONE;
    4081             :         }
    4082           1 :         if (object->aipListenAddrs == NULL) {
    4083           0 :                 py_aipListenAddrs = Py_None;
    4084           0 :                 Py_INCREF(py_aipListenAddrs);
    4085             :         } else {
    4086           1 :                 py_aipListenAddrs = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipListenAddrs, object->aipListenAddrs);
    4087             :         }
    4088           1 :         return py_aipListenAddrs;
    4089             : }
    4090             : 
    4091           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_aipListenAddrs(PyObject *py_obj, PyObject *value, void *closure)
    4092             : {
    4093           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    4094           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipListenAddrs));
    4095           0 :         if (value == NULL) {
    4096           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipListenAddrs");
    4097           0 :                 return -1;
    4098             :         }
    4099           0 :         if (value == Py_None) {
    4100           0 :                 object->aipListenAddrs = NULL;
    4101             :         } else {
    4102           0 :                 object->aipListenAddrs = NULL;
    4103           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
    4104           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    4105           0 :                         PyErr_NoMemory();
    4106           0 :                         return -1;
    4107             :                 }
    4108           0 :                 object->aipListenAddrs = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
    4109             :         }
    4110           0 :         return 0;
    4111             : }
    4112             : 
    4113           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_aipForwarders(PyObject *obj, void *closure)
    4114             : {
    4115           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    4116           0 :         PyObject *py_aipForwarders;
    4117           1 :         if (object->aipForwarders == NULL) {
    4118           1 :                 Py_RETURN_NONE;
    4119             :         }
    4120           0 :         if (object->aipForwarders == NULL) {
    4121           0 :                 py_aipForwarders = Py_None;
    4122           0 :                 Py_INCREF(py_aipForwarders);
    4123             :         } else {
    4124           0 :                 py_aipForwarders = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipForwarders, object->aipForwarders);
    4125             :         }
    4126           0 :         return py_aipForwarders;
    4127             : }
    4128             : 
    4129           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_aipForwarders(PyObject *py_obj, PyObject *value, void *closure)
    4130             : {
    4131           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    4132           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipForwarders));
    4133           0 :         if (value == NULL) {
    4134           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipForwarders");
    4135           0 :                 return -1;
    4136             :         }
    4137           0 :         if (value == Py_None) {
    4138           0 :                 object->aipForwarders = NULL;
    4139             :         } else {
    4140           0 :                 object->aipForwarders = NULL;
    4141           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
    4142           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    4143           0 :                         PyErr_NoMemory();
    4144           0 :                         return -1;
    4145             :                 }
    4146           0 :                 object->aipForwarders = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
    4147             :         }
    4148           0 :         return 0;
    4149             : }
    4150             : 
    4151           0 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_pExtension1(PyObject *obj, void *closure)
    4152             : {
    4153           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    4154           0 :         PyObject *py_pExtension1;
    4155           0 :         if (object->pExtension1 == NULL) {
    4156           0 :                 Py_RETURN_NONE;
    4157             :         }
    4158           0 :         if (object->pExtension1 == NULL) {
    4159           0 :                 py_pExtension1 = Py_None;
    4160           0 :                 Py_INCREF(py_pExtension1);
    4161             :         } else {
    4162           0 :                 py_pExtension1 = PyLong_FromUnsignedLongLong((uint32_t)(*object->pExtension1));
    4163             :         }
    4164           0 :         return py_pExtension1;
    4165             : }
    4166             : 
    4167           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_pExtension1(PyObject *py_obj, PyObject *value, void *closure)
    4168             : {
    4169           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    4170           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->pExtension1));
    4171           0 :         if (value == NULL) {
    4172           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pExtension1");
    4173           0 :                 return -1;
    4174             :         }
    4175           0 :         if (value == Py_None) {
    4176           0 :                 object->pExtension1 = NULL;
    4177             :         } else {
    4178           0 :                 object->pExtension1 = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->pExtension1);
    4179           0 :                 if (object->pExtension1 == NULL) {
    4180           0 :                         PyErr_NoMemory();
    4181           0 :                         return -1;
    4182             :                 }
    4183             :                 {
    4184           0 :                         const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->pExtension1));
    4185           0 :                         if (PyLong_Check(value)) {
    4186           0 :                                 unsigned long long test_var;
    4187           0 :                                 test_var = PyLong_AsUnsignedLongLong(value);
    4188           0 :                                 if (PyErr_Occurred() != NULL) {
    4189           0 :                                         return -1;
    4190             :                                 }
    4191           0 :                                 if (test_var > uint_max) {
    4192           0 :                                         PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4193             :                                           PyLong_Type.tp_name, uint_max, test_var);
    4194           0 :                                         return -1;
    4195             :                                 }
    4196           0 :                                 *object->pExtension1 = test_var;
    4197             :                         } else {
    4198           0 :                                 PyErr_Format(PyExc_TypeError, "Expected type %s",
    4199             :                                   PyLong_Type.tp_name);
    4200           0 :                                 return -1;
    4201             :                         }
    4202             :                 }
    4203             :         }
    4204           0 :         return 0;
    4205             : }
    4206             : 
    4207           0 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_pExtension2(PyObject *obj, void *closure)
    4208             : {
    4209           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    4210           0 :         PyObject *py_pExtension2;
    4211           0 :         if (object->pExtension2 == NULL) {
    4212           0 :                 Py_RETURN_NONE;
    4213             :         }
    4214           0 :         if (object->pExtension2 == NULL) {
    4215           0 :                 py_pExtension2 = Py_None;
    4216           0 :                 Py_INCREF(py_pExtension2);
    4217             :         } else {
    4218           0 :                 py_pExtension2 = PyLong_FromUnsignedLongLong((uint32_t)(*object->pExtension2));
    4219             :         }
    4220           0 :         return py_pExtension2;
    4221             : }
    4222             : 
    4223           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_pExtension2(PyObject *py_obj, PyObject *value, void *closure)
    4224             : {
    4225           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    4226           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->pExtension2));
    4227           0 :         if (value == NULL) {
    4228           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pExtension2");
    4229           0 :                 return -1;
    4230             :         }
    4231           0 :         if (value == Py_None) {
    4232           0 :                 object->pExtension2 = NULL;
    4233             :         } else {
    4234           0 :                 object->pExtension2 = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->pExtension2);
    4235           0 :                 if (object->pExtension2 == NULL) {
    4236           0 :                         PyErr_NoMemory();
    4237           0 :                         return -1;
    4238             :                 }
    4239             :                 {
    4240           0 :                         const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->pExtension2));
    4241           0 :                         if (PyLong_Check(value)) {
    4242           0 :                                 unsigned long long test_var;
    4243           0 :                                 test_var = PyLong_AsUnsignedLongLong(value);
    4244           0 :                                 if (PyErr_Occurred() != NULL) {
    4245           0 :                                         return -1;
    4246             :                                 }
    4247           0 :                                 if (test_var > uint_max) {
    4248           0 :                                         PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4249             :                                           PyLong_Type.tp_name, uint_max, test_var);
    4250           0 :                                         return -1;
    4251             :                                 }
    4252           0 :                                 *object->pExtension2 = test_var;
    4253             :                         } else {
    4254           0 :                                 PyErr_Format(PyExc_TypeError, "Expected type %s",
    4255             :                                   PyLong_Type.tp_name);
    4256           0 :                                 return -1;
    4257             :                         }
    4258             :                 }
    4259             :         }
    4260           0 :         return 0;
    4261             : }
    4262             : 
    4263           0 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_pExtension3(PyObject *obj, void *closure)
    4264             : {
    4265           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    4266           0 :         PyObject *py_pExtension3;
    4267           0 :         if (object->pExtension3 == NULL) {
    4268           0 :                 Py_RETURN_NONE;
    4269             :         }
    4270           0 :         if (object->pExtension3 == NULL) {
    4271           0 :                 py_pExtension3 = Py_None;
    4272           0 :                 Py_INCREF(py_pExtension3);
    4273             :         } else {
    4274           0 :                 py_pExtension3 = PyLong_FromUnsignedLongLong((uint32_t)(*object->pExtension3));
    4275             :         }
    4276           0 :         return py_pExtension3;
    4277             : }
    4278             : 
    4279           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_pExtension3(PyObject *py_obj, PyObject *value, void *closure)
    4280             : {
    4281           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    4282           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->pExtension3));
    4283           0 :         if (value == NULL) {
    4284           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pExtension3");
    4285           0 :                 return -1;
    4286             :         }
    4287           0 :         if (value == Py_None) {
    4288           0 :                 object->pExtension3 = NULL;
    4289             :         } else {
    4290           0 :                 object->pExtension3 = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->pExtension3);
    4291           0 :                 if (object->pExtension3 == NULL) {
    4292           0 :                         PyErr_NoMemory();
    4293           0 :                         return -1;
    4294             :                 }
    4295             :                 {
    4296           0 :                         const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->pExtension3));
    4297           0 :                         if (PyLong_Check(value)) {
    4298           0 :                                 unsigned long long test_var;
    4299           0 :                                 test_var = PyLong_AsUnsignedLongLong(value);
    4300           0 :                                 if (PyErr_Occurred() != NULL) {
    4301           0 :                                         return -1;
    4302             :                                 }
    4303           0 :                                 if (test_var > uint_max) {
    4304           0 :                                         PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4305             :                                           PyLong_Type.tp_name, uint_max, test_var);
    4306           0 :                                         return -1;
    4307             :                                 }
    4308           0 :                                 *object->pExtension3 = test_var;
    4309             :                         } else {
    4310           0 :                                 PyErr_Format(PyExc_TypeError, "Expected type %s",
    4311             :                                   PyLong_Type.tp_name);
    4312           0 :                                 return -1;
    4313             :                         }
    4314             :                 }
    4315             :         }
    4316           0 :         return 0;
    4317             : }
    4318             : 
    4319           0 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_pExtension4(PyObject *obj, void *closure)
    4320             : {
    4321           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    4322           0 :         PyObject *py_pExtension4;
    4323           0 :         if (object->pExtension4 == NULL) {
    4324           0 :                 Py_RETURN_NONE;
    4325             :         }
    4326           0 :         if (object->pExtension4 == NULL) {
    4327           0 :                 py_pExtension4 = Py_None;
    4328           0 :                 Py_INCREF(py_pExtension4);
    4329             :         } else {
    4330           0 :                 py_pExtension4 = PyLong_FromUnsignedLongLong((uint32_t)(*object->pExtension4));
    4331             :         }
    4332           0 :         return py_pExtension4;
    4333             : }
    4334             : 
    4335           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_pExtension4(PyObject *py_obj, PyObject *value, void *closure)
    4336             : {
    4337           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    4338           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->pExtension4));
    4339           0 :         if (value == NULL) {
    4340           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pExtension4");
    4341           0 :                 return -1;
    4342             :         }
    4343           0 :         if (value == Py_None) {
    4344           0 :                 object->pExtension4 = NULL;
    4345             :         } else {
    4346           0 :                 object->pExtension4 = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->pExtension4);
    4347           0 :                 if (object->pExtension4 == NULL) {
    4348           0 :                         PyErr_NoMemory();
    4349           0 :                         return -1;
    4350             :                 }
    4351             :                 {
    4352           0 :                         const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->pExtension4));
    4353           0 :                         if (PyLong_Check(value)) {
    4354           0 :                                 unsigned long long test_var;
    4355           0 :                                 test_var = PyLong_AsUnsignedLongLong(value);
    4356           0 :                                 if (PyErr_Occurred() != NULL) {
    4357           0 :                                         return -1;
    4358             :                                 }
    4359           0 :                                 if (test_var > uint_max) {
    4360           0 :                                         PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4361             :                                           PyLong_Type.tp_name, uint_max, test_var);
    4362           0 :                                         return -1;
    4363             :                                 }
    4364           0 :                                 *object->pExtension4 = test_var;
    4365             :                         } else {
    4366           0 :                                 PyErr_Format(PyExc_TypeError, "Expected type %s",
    4367             :                                   PyLong_Type.tp_name);
    4368           0 :                                 return -1;
    4369             :                         }
    4370             :                 }
    4371             :         }
    4372           0 :         return 0;
    4373             : }
    4374             : 
    4375           0 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_pExtension5(PyObject *obj, void *closure)
    4376             : {
    4377           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    4378           0 :         PyObject *py_pExtension5;
    4379           0 :         if (object->pExtension5 == NULL) {
    4380           0 :                 Py_RETURN_NONE;
    4381             :         }
    4382           0 :         if (object->pExtension5 == NULL) {
    4383           0 :                 py_pExtension5 = Py_None;
    4384           0 :                 Py_INCREF(py_pExtension5);
    4385             :         } else {
    4386           0 :                 py_pExtension5 = PyLong_FromUnsignedLongLong((uint32_t)(*object->pExtension5));
    4387             :         }
    4388           0 :         return py_pExtension5;
    4389             : }
    4390             : 
    4391           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_pExtension5(PyObject *py_obj, PyObject *value, void *closure)
    4392             : {
    4393           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    4394           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->pExtension5));
    4395           0 :         if (value == NULL) {
    4396           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pExtension5");
    4397           0 :                 return -1;
    4398             :         }
    4399           0 :         if (value == Py_None) {
    4400           0 :                 object->pExtension5 = NULL;
    4401             :         } else {
    4402           0 :                 object->pExtension5 = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->pExtension5);
    4403           0 :                 if (object->pExtension5 == NULL) {
    4404           0 :                         PyErr_NoMemory();
    4405           0 :                         return -1;
    4406             :                 }
    4407             :                 {
    4408           0 :                         const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->pExtension5));
    4409           0 :                         if (PyLong_Check(value)) {
    4410           0 :                                 unsigned long long test_var;
    4411           0 :                                 test_var = PyLong_AsUnsignedLongLong(value);
    4412           0 :                                 if (PyErr_Occurred() != NULL) {
    4413           0 :                                         return -1;
    4414             :                                 }
    4415           0 :                                 if (test_var > uint_max) {
    4416           0 :                                         PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4417             :                                           PyLong_Type.tp_name, uint_max, test_var);
    4418           0 :                                         return -1;
    4419             :                                 }
    4420           0 :                                 *object->pExtension5 = test_var;
    4421             :                         } else {
    4422           0 :                                 PyErr_Format(PyExc_TypeError, "Expected type %s",
    4423             :                                   PyLong_Type.tp_name);
    4424           0 :                                 return -1;
    4425             :                         }
    4426             :                 }
    4427             :         }
    4428           0 :         return 0;
    4429             : }
    4430             : 
    4431           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_dwLogLevel(PyObject *obj, void *closure)
    4432             : {
    4433           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    4434           0 :         PyObject *py_dwLogLevel;
    4435           1 :         py_dwLogLevel = PyLong_FromUnsignedLongLong((uint32_t)(object->dwLogLevel));
    4436           1 :         return py_dwLogLevel;
    4437             : }
    4438             : 
    4439           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_dwLogLevel(PyObject *py_obj, PyObject *value, void *closure)
    4440             : {
    4441           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    4442           0 :         if (value == NULL) {
    4443           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwLogLevel");
    4444           0 :                 return -1;
    4445             :         }
    4446             :         {
    4447           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwLogLevel));
    4448           0 :                 if (PyLong_Check(value)) {
    4449           0 :                         unsigned long long test_var;
    4450           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    4451           0 :                         if (PyErr_Occurred() != NULL) {
    4452           0 :                                 return -1;
    4453             :                         }
    4454           0 :                         if (test_var > uint_max) {
    4455           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4456             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4457           0 :                                 return -1;
    4458             :                         }
    4459           0 :                         object->dwLogLevel = test_var;
    4460             :                 } else {
    4461           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4462             :                           PyLong_Type.tp_name);
    4463           0 :                         return -1;
    4464             :                 }
    4465             :         }
    4466           0 :         return 0;
    4467             : }
    4468             : 
    4469           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_dwDebugLevel(PyObject *obj, void *closure)
    4470             : {
    4471           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    4472           0 :         PyObject *py_dwDebugLevel;
    4473           1 :         py_dwDebugLevel = PyLong_FromUnsignedLongLong((uint32_t)(object->dwDebugLevel));
    4474           1 :         return py_dwDebugLevel;
    4475             : }
    4476             : 
    4477           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_dwDebugLevel(PyObject *py_obj, PyObject *value, void *closure)
    4478             : {
    4479           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    4480           0 :         if (value == NULL) {
    4481           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwDebugLevel");
    4482           0 :                 return -1;
    4483             :         }
    4484             :         {
    4485           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwDebugLevel));
    4486           0 :                 if (PyLong_Check(value)) {
    4487           0 :                         unsigned long long test_var;
    4488           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    4489           0 :                         if (PyErr_Occurred() != NULL) {
    4490           0 :                                 return -1;
    4491             :                         }
    4492           0 :                         if (test_var > uint_max) {
    4493           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4494             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4495           0 :                                 return -1;
    4496             :                         }
    4497           0 :                         object->dwDebugLevel = test_var;
    4498             :                 } else {
    4499           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4500             :                           PyLong_Type.tp_name);
    4501           0 :                         return -1;
    4502             :                 }
    4503             :         }
    4504           0 :         return 0;
    4505             : }
    4506             : 
    4507           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_dwForwardTimeout(PyObject *obj, void *closure)
    4508             : {
    4509           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    4510           0 :         PyObject *py_dwForwardTimeout;
    4511           1 :         py_dwForwardTimeout = PyLong_FromUnsignedLongLong((uint32_t)(object->dwForwardTimeout));
    4512           1 :         return py_dwForwardTimeout;
    4513             : }
    4514             : 
    4515           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_dwForwardTimeout(PyObject *py_obj, PyObject *value, void *closure)
    4516             : {
    4517           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    4518           0 :         if (value == NULL) {
    4519           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwForwardTimeout");
    4520           0 :                 return -1;
    4521             :         }
    4522             :         {
    4523           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwForwardTimeout));
    4524           0 :                 if (PyLong_Check(value)) {
    4525           0 :                         unsigned long long test_var;
    4526           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    4527           0 :                         if (PyErr_Occurred() != NULL) {
    4528           0 :                                 return -1;
    4529             :                         }
    4530           0 :                         if (test_var > uint_max) {
    4531           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4532             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4533           0 :                                 return -1;
    4534             :                         }
    4535           0 :                         object->dwForwardTimeout = test_var;
    4536             :                 } else {
    4537           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4538             :                           PyLong_Type.tp_name);
    4539           0 :                         return -1;
    4540             :                 }
    4541             :         }
    4542           0 :         return 0;
    4543             : }
    4544             : 
    4545           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_dwRpcProtocol(PyObject *obj, void *closure)
    4546             : {
    4547           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    4548           0 :         PyObject *py_dwRpcProtocol;
    4549           1 :         py_dwRpcProtocol = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcProtocol));
    4550           1 :         return py_dwRpcProtocol;
    4551             : }
    4552             : 
    4553           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_dwRpcProtocol(PyObject *py_obj, PyObject *value, void *closure)
    4554             : {
    4555           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    4556           0 :         if (value == NULL) {
    4557           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcProtocol");
    4558           0 :                 return -1;
    4559             :         }
    4560             :         {
    4561           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcProtocol));
    4562           0 :                 if (PyLong_Check(value)) {
    4563           0 :                         unsigned long long test_var;
    4564           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    4565           0 :                         if (PyErr_Occurred() != NULL) {
    4566           0 :                                 return -1;
    4567             :                         }
    4568           0 :                         if (test_var > uint_max) {
    4569           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4570             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4571           0 :                                 return -1;
    4572             :                         }
    4573           0 :                         object->dwRpcProtocol = test_var;
    4574             :                 } else {
    4575           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4576             :                           PyLong_Type.tp_name);
    4577           0 :                         return -1;
    4578             :                 }
    4579             :         }
    4580           0 :         return 0;
    4581             : }
    4582             : 
    4583           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_dwNameCheckFlag(PyObject *obj, void *closure)
    4584             : {
    4585           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    4586           0 :         PyObject *py_dwNameCheckFlag;
    4587           1 :         py_dwNameCheckFlag = PyLong_FromUnsignedLongLong((uint32_t)(object->dwNameCheckFlag));
    4588           1 :         return py_dwNameCheckFlag;
    4589             : }
    4590             : 
    4591           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_dwNameCheckFlag(PyObject *py_obj, PyObject *value, void *closure)
    4592             : {
    4593           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    4594           0 :         if (value == NULL) {
    4595           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwNameCheckFlag");
    4596           0 :                 return -1;
    4597             :         }
    4598             :         {
    4599           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwNameCheckFlag));
    4600           0 :                 if (PyLong_Check(value)) {
    4601           0 :                         unsigned long long test_var;
    4602           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    4603           0 :                         if (PyErr_Occurred() != NULL) {
    4604           0 :                                 return -1;
    4605             :                         }
    4606           0 :                         if (test_var > uint_max) {
    4607           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4608             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4609           0 :                                 return -1;
    4610             :                         }
    4611           0 :                         object->dwNameCheckFlag = test_var;
    4612             :                 } else {
    4613           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4614             :                           PyLong_Type.tp_name);
    4615           0 :                         return -1;
    4616             :                 }
    4617             :         }
    4618           0 :         return 0;
    4619             : }
    4620             : 
    4621           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_cAddressAnswerLimit(PyObject *obj, void *closure)
    4622             : {
    4623           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    4624           0 :         PyObject *py_cAddressAnswerLimit;
    4625           1 :         py_cAddressAnswerLimit = PyLong_FromUnsignedLongLong((uint32_t)(object->cAddressAnswerLimit));
    4626           1 :         return py_cAddressAnswerLimit;
    4627             : }
    4628             : 
    4629           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_cAddressAnswerLimit(PyObject *py_obj, PyObject *value, void *closure)
    4630             : {
    4631           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    4632           0 :         if (value == NULL) {
    4633           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->cAddressAnswerLimit");
    4634           0 :                 return -1;
    4635             :         }
    4636             :         {
    4637           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->cAddressAnswerLimit));
    4638           0 :                 if (PyLong_Check(value)) {
    4639           0 :                         unsigned long long test_var;
    4640           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    4641           0 :                         if (PyErr_Occurred() != NULL) {
    4642           0 :                                 return -1;
    4643             :                         }
    4644           0 :                         if (test_var > uint_max) {
    4645           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4646             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4647           0 :                                 return -1;
    4648             :                         }
    4649           0 :                         object->cAddressAnswerLimit = test_var;
    4650             :                 } else {
    4651           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4652             :                           PyLong_Type.tp_name);
    4653           0 :                         return -1;
    4654             :                 }
    4655             :         }
    4656           0 :         return 0;
    4657             : }
    4658             : 
    4659           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_dwRecursionRetry(PyObject *obj, void *closure)
    4660             : {
    4661           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    4662           0 :         PyObject *py_dwRecursionRetry;
    4663           1 :         py_dwRecursionRetry = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRecursionRetry));
    4664           1 :         return py_dwRecursionRetry;
    4665             : }
    4666             : 
    4667           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_dwRecursionRetry(PyObject *py_obj, PyObject *value, void *closure)
    4668             : {
    4669           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    4670           0 :         if (value == NULL) {
    4671           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRecursionRetry");
    4672           0 :                 return -1;
    4673             :         }
    4674             :         {
    4675           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRecursionRetry));
    4676           0 :                 if (PyLong_Check(value)) {
    4677           0 :                         unsigned long long test_var;
    4678           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    4679           0 :                         if (PyErr_Occurred() != NULL) {
    4680           0 :                                 return -1;
    4681             :                         }
    4682           0 :                         if (test_var > uint_max) {
    4683           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4684             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4685           0 :                                 return -1;
    4686             :                         }
    4687           0 :                         object->dwRecursionRetry = test_var;
    4688             :                 } else {
    4689           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4690             :                           PyLong_Type.tp_name);
    4691           0 :                         return -1;
    4692             :                 }
    4693             :         }
    4694           0 :         return 0;
    4695             : }
    4696             : 
    4697           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_dwRecursionTimeout(PyObject *obj, void *closure)
    4698             : {
    4699           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    4700           0 :         PyObject *py_dwRecursionTimeout;
    4701           1 :         py_dwRecursionTimeout = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRecursionTimeout));
    4702           1 :         return py_dwRecursionTimeout;
    4703             : }
    4704             : 
    4705           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_dwRecursionTimeout(PyObject *py_obj, PyObject *value, void *closure)
    4706             : {
    4707           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    4708           0 :         if (value == NULL) {
    4709           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRecursionTimeout");
    4710           0 :                 return -1;
    4711             :         }
    4712             :         {
    4713           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRecursionTimeout));
    4714           0 :                 if (PyLong_Check(value)) {
    4715           0 :                         unsigned long long test_var;
    4716           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    4717           0 :                         if (PyErr_Occurred() != NULL) {
    4718           0 :                                 return -1;
    4719             :                         }
    4720           0 :                         if (test_var > uint_max) {
    4721           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4722             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4723           0 :                                 return -1;
    4724             :                         }
    4725           0 :                         object->dwRecursionTimeout = test_var;
    4726             :                 } else {
    4727           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4728             :                           PyLong_Type.tp_name);
    4729           0 :                         return -1;
    4730             :                 }
    4731             :         }
    4732           0 :         return 0;
    4733             : }
    4734             : 
    4735           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_dwMaxCacheTtl(PyObject *obj, void *closure)
    4736             : {
    4737           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    4738           0 :         PyObject *py_dwMaxCacheTtl;
    4739           1 :         py_dwMaxCacheTtl = PyLong_FromUnsignedLongLong((uint32_t)(object->dwMaxCacheTtl));
    4740           1 :         return py_dwMaxCacheTtl;
    4741             : }
    4742             : 
    4743           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_dwMaxCacheTtl(PyObject *py_obj, PyObject *value, void *closure)
    4744             : {
    4745           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    4746           0 :         if (value == NULL) {
    4747           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwMaxCacheTtl");
    4748           0 :                 return -1;
    4749             :         }
    4750             :         {
    4751           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwMaxCacheTtl));
    4752           0 :                 if (PyLong_Check(value)) {
    4753           0 :                         unsigned long long test_var;
    4754           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    4755           0 :                         if (PyErr_Occurred() != NULL) {
    4756           0 :                                 return -1;
    4757             :                         }
    4758           0 :                         if (test_var > uint_max) {
    4759           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4760             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4761           0 :                                 return -1;
    4762             :                         }
    4763           0 :                         object->dwMaxCacheTtl = test_var;
    4764             :                 } else {
    4765           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4766             :                           PyLong_Type.tp_name);
    4767           0 :                         return -1;
    4768             :                 }
    4769             :         }
    4770           0 :         return 0;
    4771             : }
    4772             : 
    4773           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_dwDsPollingInterval(PyObject *obj, void *closure)
    4774             : {
    4775           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    4776           0 :         PyObject *py_dwDsPollingInterval;
    4777           1 :         py_dwDsPollingInterval = PyLong_FromUnsignedLongLong((uint32_t)(object->dwDsPollingInterval));
    4778           1 :         return py_dwDsPollingInterval;
    4779             : }
    4780             : 
    4781           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_dwDsPollingInterval(PyObject *py_obj, PyObject *value, void *closure)
    4782             : {
    4783           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    4784           0 :         if (value == NULL) {
    4785           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwDsPollingInterval");
    4786           0 :                 return -1;
    4787             :         }
    4788             :         {
    4789           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwDsPollingInterval));
    4790           0 :                 if (PyLong_Check(value)) {
    4791           0 :                         unsigned long long test_var;
    4792           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    4793           0 :                         if (PyErr_Occurred() != NULL) {
    4794           0 :                                 return -1;
    4795             :                         }
    4796           0 :                         if (test_var > uint_max) {
    4797           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4798             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4799           0 :                                 return -1;
    4800             :                         }
    4801           0 :                         object->dwDsPollingInterval = test_var;
    4802             :                 } else {
    4803           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4804             :                           PyLong_Type.tp_name);
    4805           0 :                         return -1;
    4806             :                 }
    4807             :         }
    4808           0 :         return 0;
    4809             : }
    4810             : 
    4811           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_dwScavengingInterval(PyObject *obj, void *closure)
    4812             : {
    4813           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    4814           0 :         PyObject *py_dwScavengingInterval;
    4815           1 :         py_dwScavengingInterval = PyLong_FromUnsignedLongLong((uint32_t)(object->dwScavengingInterval));
    4816           1 :         return py_dwScavengingInterval;
    4817             : }
    4818             : 
    4819           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_dwScavengingInterval(PyObject *py_obj, PyObject *value, void *closure)
    4820             : {
    4821           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    4822           0 :         if (value == NULL) {
    4823           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwScavengingInterval");
    4824           0 :                 return -1;
    4825             :         }
    4826             :         {
    4827           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwScavengingInterval));
    4828           0 :                 if (PyLong_Check(value)) {
    4829           0 :                         unsigned long long test_var;
    4830           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    4831           0 :                         if (PyErr_Occurred() != NULL) {
    4832           0 :                                 return -1;
    4833             :                         }
    4834           0 :                         if (test_var > uint_max) {
    4835           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4836             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4837           0 :                                 return -1;
    4838             :                         }
    4839           0 :                         object->dwScavengingInterval = test_var;
    4840             :                 } else {
    4841           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4842             :                           PyLong_Type.tp_name);
    4843           0 :                         return -1;
    4844             :                 }
    4845             :         }
    4846           0 :         return 0;
    4847             : }
    4848             : 
    4849           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_dwDefaultRefreshInterval(PyObject *obj, void *closure)
    4850             : {
    4851           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    4852           0 :         PyObject *py_dwDefaultRefreshInterval;
    4853           1 :         py_dwDefaultRefreshInterval = PyLong_FromUnsignedLongLong((uint32_t)(object->dwDefaultRefreshInterval));
    4854           1 :         return py_dwDefaultRefreshInterval;
    4855             : }
    4856             : 
    4857           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_dwDefaultRefreshInterval(PyObject *py_obj, PyObject *value, void *closure)
    4858             : {
    4859           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    4860           0 :         if (value == NULL) {
    4861           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwDefaultRefreshInterval");
    4862           0 :                 return -1;
    4863             :         }
    4864             :         {
    4865           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwDefaultRefreshInterval));
    4866           0 :                 if (PyLong_Check(value)) {
    4867           0 :                         unsigned long long test_var;
    4868           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    4869           0 :                         if (PyErr_Occurred() != NULL) {
    4870           0 :                                 return -1;
    4871             :                         }
    4872           0 :                         if (test_var > uint_max) {
    4873           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4874             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4875           0 :                                 return -1;
    4876             :                         }
    4877           0 :                         object->dwDefaultRefreshInterval = test_var;
    4878             :                 } else {
    4879           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4880             :                           PyLong_Type.tp_name);
    4881           0 :                         return -1;
    4882             :                 }
    4883             :         }
    4884           0 :         return 0;
    4885             : }
    4886             : 
    4887           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_dwDefaultNoRefreshInterval(PyObject *obj, void *closure)
    4888             : {
    4889           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    4890           0 :         PyObject *py_dwDefaultNoRefreshInterval;
    4891           1 :         py_dwDefaultNoRefreshInterval = PyLong_FromUnsignedLongLong((uint32_t)(object->dwDefaultNoRefreshInterval));
    4892           1 :         return py_dwDefaultNoRefreshInterval;
    4893             : }
    4894             : 
    4895           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_dwDefaultNoRefreshInterval(PyObject *py_obj, PyObject *value, void *closure)
    4896             : {
    4897           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    4898           0 :         if (value == NULL) {
    4899           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwDefaultNoRefreshInterval");
    4900           0 :                 return -1;
    4901             :         }
    4902             :         {
    4903           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwDefaultNoRefreshInterval));
    4904           0 :                 if (PyLong_Check(value)) {
    4905           0 :                         unsigned long long test_var;
    4906           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    4907           0 :                         if (PyErr_Occurred() != NULL) {
    4908           0 :                                 return -1;
    4909             :                         }
    4910           0 :                         if (test_var > uint_max) {
    4911           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4912             :                                   PyLong_Type.tp_name, uint_max, test_var);
    4913           0 :                                 return -1;
    4914             :                         }
    4915           0 :                         object->dwDefaultNoRefreshInterval = test_var;
    4916             :                 } else {
    4917           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4918             :                           PyLong_Type.tp_name);
    4919           0 :                         return -1;
    4920             :                 }
    4921             :         }
    4922           0 :         return 0;
    4923             : }
    4924             : 
    4925           0 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_dwReserveArray(PyObject *obj, void *closure)
    4926             : {
    4927           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    4928           0 :         PyObject *py_dwReserveArray;
    4929           0 :         py_dwReserveArray = PyList_New(10);
    4930           0 :         if (py_dwReserveArray == NULL) {
    4931           0 :                 return NULL;
    4932             :         }
    4933             :         {
    4934             :                 int dwReserveArray_cntr_0;
    4935           0 :                 for (dwReserveArray_cntr_0 = 0; dwReserveArray_cntr_0 < (10); dwReserveArray_cntr_0++) {
    4936           0 :                         PyObject *py_dwReserveArray_0;
    4937           0 :                         py_dwReserveArray_0 = PyLong_FromUnsignedLongLong((uint32_t)((object->dwReserveArray)[dwReserveArray_cntr_0]));
    4938           0 :                         PyList_SetItem(py_dwReserveArray, dwReserveArray_cntr_0, py_dwReserveArray_0);
    4939             :                 }
    4940             :         }
    4941           0 :         return py_dwReserveArray;
    4942             : }
    4943             : 
    4944           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_dwReserveArray(PyObject *py_obj, PyObject *value, void *closure)
    4945             : {
    4946           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    4947           0 :         if (value == NULL) {
    4948           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserveArray");
    4949           0 :                 return -1;
    4950             :         }
    4951           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
    4952             :         {
    4953           0 :                 int dwReserveArray_cntr_0;
    4954           0 :                 if (ARRAY_SIZE(object->dwReserveArray) != PyList_GET_SIZE(value)) {
    4955           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));
    4956           0 :                         return -1;
    4957             :                 }
    4958           0 :                 for (dwReserveArray_cntr_0 = 0; dwReserveArray_cntr_0 < PyList_GET_SIZE(value); dwReserveArray_cntr_0++) {
    4959           0 :                         if (PyList_GET_ITEM(value, dwReserveArray_cntr_0) == NULL) {
    4960           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->dwReserveArray)[dwReserveArray_cntr_0]");
    4961           0 :                                 return -1;
    4962             :                         }
    4963             :                         {
    4964           0 :                                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof((object->dwReserveArray)[dwReserveArray_cntr_0]));
    4965           0 :                                 if (PyLong_Check(PyList_GET_ITEM(value, dwReserveArray_cntr_0))) {
    4966           0 :                                         unsigned long long test_var;
    4967           0 :                                         test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, dwReserveArray_cntr_0));
    4968           0 :                                         if (PyErr_Occurred() != NULL) {
    4969           0 :                                                 return -1;
    4970             :                                         }
    4971           0 :                                         if (test_var > uint_max) {
    4972           0 :                                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    4973             :                                                   PyLong_Type.tp_name, uint_max, test_var);
    4974           0 :                                                 return -1;
    4975             :                                         }
    4976           0 :                                         (object->dwReserveArray)[dwReserveArray_cntr_0] = test_var;
    4977             :                                 } else {
    4978           0 :                                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    4979             :                                           PyLong_Type.tp_name);
    4980           0 :                                         return -1;
    4981             :                                 }
    4982             :                         }
    4983             :                 }
    4984             :         }
    4985           0 :         return 0;
    4986             : }
    4987             : 
    4988           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_fAutoReverseZones(PyObject *obj, void *closure)
    4989             : {
    4990           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    4991           0 :         PyObject *py_fAutoReverseZones;
    4992           1 :         py_fAutoReverseZones = PyLong_FromLong((uint16_t)(object->fAutoReverseZones));
    4993           1 :         return py_fAutoReverseZones;
    4994             : }
    4995             : 
    4996           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_fAutoReverseZones(PyObject *py_obj, PyObject *value, void *closure)
    4997             : {
    4998           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    4999           0 :         if (value == NULL) {
    5000           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAutoReverseZones");
    5001           0 :                 return -1;
    5002             :         }
    5003             :         {
    5004           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAutoReverseZones));
    5005           0 :                 if (PyLong_Check(value)) {
    5006           0 :                         unsigned long long test_var;
    5007           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    5008           0 :                         if (PyErr_Occurred() != NULL) {
    5009           0 :                                 return -1;
    5010             :                         }
    5011           0 :                         if (test_var > uint_max) {
    5012           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    5013             :                                   PyLong_Type.tp_name, uint_max, test_var);
    5014           0 :                                 return -1;
    5015             :                         }
    5016           0 :                         object->fAutoReverseZones = test_var;
    5017             :                 } else {
    5018           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    5019             :                           PyLong_Type.tp_name);
    5020           0 :                         return -1;
    5021             :                 }
    5022             :         }
    5023           0 :         return 0;
    5024             : }
    5025             : 
    5026           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_fAutoCacheUpdate(PyObject *obj, void *closure)
    5027             : {
    5028           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    5029           0 :         PyObject *py_fAutoCacheUpdate;
    5030           1 :         py_fAutoCacheUpdate = PyLong_FromLong((uint16_t)(object->fAutoCacheUpdate));
    5031           1 :         return py_fAutoCacheUpdate;
    5032             : }
    5033             : 
    5034           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_fAutoCacheUpdate(PyObject *py_obj, PyObject *value, void *closure)
    5035             : {
    5036           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    5037           0 :         if (value == NULL) {
    5038           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAutoCacheUpdate");
    5039           0 :                 return -1;
    5040             :         }
    5041             :         {
    5042           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAutoCacheUpdate));
    5043           0 :                 if (PyLong_Check(value)) {
    5044           0 :                         unsigned long long test_var;
    5045           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    5046           0 :                         if (PyErr_Occurred() != NULL) {
    5047           0 :                                 return -1;
    5048             :                         }
    5049           0 :                         if (test_var > uint_max) {
    5050           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    5051             :                                   PyLong_Type.tp_name, uint_max, test_var);
    5052           0 :                                 return -1;
    5053             :                         }
    5054           0 :                         object->fAutoCacheUpdate = test_var;
    5055             :                 } else {
    5056           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    5057             :                           PyLong_Type.tp_name);
    5058           0 :                         return -1;
    5059             :                 }
    5060             :         }
    5061           0 :         return 0;
    5062             : }
    5063             : 
    5064           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_fRecurseAfterForwarding(PyObject *obj, void *closure)
    5065             : {
    5066           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    5067           0 :         PyObject *py_fRecurseAfterForwarding;
    5068           1 :         py_fRecurseAfterForwarding = PyLong_FromLong((uint16_t)(object->fRecurseAfterForwarding));
    5069           1 :         return py_fRecurseAfterForwarding;
    5070             : }
    5071             : 
    5072           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_fRecurseAfterForwarding(PyObject *py_obj, PyObject *value, void *closure)
    5073             : {
    5074           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    5075           0 :         if (value == NULL) {
    5076           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fRecurseAfterForwarding");
    5077           0 :                 return -1;
    5078             :         }
    5079             :         {
    5080           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fRecurseAfterForwarding));
    5081           0 :                 if (PyLong_Check(value)) {
    5082           0 :                         unsigned long long test_var;
    5083           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    5084           0 :                         if (PyErr_Occurred() != NULL) {
    5085           0 :                                 return -1;
    5086             :                         }
    5087           0 :                         if (test_var > uint_max) {
    5088           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    5089             :                                   PyLong_Type.tp_name, uint_max, test_var);
    5090           0 :                                 return -1;
    5091             :                         }
    5092           0 :                         object->fRecurseAfterForwarding = test_var;
    5093             :                 } else {
    5094           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    5095             :                           PyLong_Type.tp_name);
    5096           0 :                         return -1;
    5097             :                 }
    5098             :         }
    5099           0 :         return 0;
    5100             : }
    5101             : 
    5102           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_fForwardDelegations(PyObject *obj, void *closure)
    5103             : {
    5104           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    5105           0 :         PyObject *py_fForwardDelegations;
    5106           1 :         py_fForwardDelegations = PyLong_FromLong((uint16_t)(object->fForwardDelegations));
    5107           1 :         return py_fForwardDelegations;
    5108             : }
    5109             : 
    5110           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_fForwardDelegations(PyObject *py_obj, PyObject *value, void *closure)
    5111             : {
    5112           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    5113           0 :         if (value == NULL) {
    5114           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fForwardDelegations");
    5115           0 :                 return -1;
    5116             :         }
    5117             :         {
    5118           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fForwardDelegations));
    5119           0 :                 if (PyLong_Check(value)) {
    5120           0 :                         unsigned long long test_var;
    5121           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    5122           0 :                         if (PyErr_Occurred() != NULL) {
    5123           0 :                                 return -1;
    5124             :                         }
    5125           0 :                         if (test_var > uint_max) {
    5126           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    5127             :                                   PyLong_Type.tp_name, uint_max, test_var);
    5128           0 :                                 return -1;
    5129             :                         }
    5130           0 :                         object->fForwardDelegations = test_var;
    5131             :                 } else {
    5132           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    5133             :                           PyLong_Type.tp_name);
    5134           0 :                         return -1;
    5135             :                 }
    5136             :         }
    5137           0 :         return 0;
    5138             : }
    5139             : 
    5140           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_fNoRecursion(PyObject *obj, void *closure)
    5141             : {
    5142           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    5143           0 :         PyObject *py_fNoRecursion;
    5144           1 :         py_fNoRecursion = PyLong_FromLong((uint16_t)(object->fNoRecursion));
    5145           1 :         return py_fNoRecursion;
    5146             : }
    5147             : 
    5148           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_fNoRecursion(PyObject *py_obj, PyObject *value, void *closure)
    5149             : {
    5150           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    5151           0 :         if (value == NULL) {
    5152           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fNoRecursion");
    5153           0 :                 return -1;
    5154             :         }
    5155             :         {
    5156           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fNoRecursion));
    5157           0 :                 if (PyLong_Check(value)) {
    5158           0 :                         unsigned long long test_var;
    5159           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    5160           0 :                         if (PyErr_Occurred() != NULL) {
    5161           0 :                                 return -1;
    5162             :                         }
    5163           0 :                         if (test_var > uint_max) {
    5164           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    5165             :                                   PyLong_Type.tp_name, uint_max, test_var);
    5166           0 :                                 return -1;
    5167             :                         }
    5168           0 :                         object->fNoRecursion = test_var;
    5169             :                 } else {
    5170           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    5171             :                           PyLong_Type.tp_name);
    5172           0 :                         return -1;
    5173             :                 }
    5174             :         }
    5175           0 :         return 0;
    5176             : }
    5177             : 
    5178           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_fSecureResponses(PyObject *obj, void *closure)
    5179             : {
    5180           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    5181           0 :         PyObject *py_fSecureResponses;
    5182           1 :         py_fSecureResponses = PyLong_FromLong((uint16_t)(object->fSecureResponses));
    5183           1 :         return py_fSecureResponses;
    5184             : }
    5185             : 
    5186           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_fSecureResponses(PyObject *py_obj, PyObject *value, void *closure)
    5187             : {
    5188           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    5189           0 :         if (value == NULL) {
    5190           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fSecureResponses");
    5191           0 :                 return -1;
    5192             :         }
    5193             :         {
    5194           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fSecureResponses));
    5195           0 :                 if (PyLong_Check(value)) {
    5196           0 :                         unsigned long long test_var;
    5197           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    5198           0 :                         if (PyErr_Occurred() != NULL) {
    5199           0 :                                 return -1;
    5200             :                         }
    5201           0 :                         if (test_var > uint_max) {
    5202           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    5203             :                                   PyLong_Type.tp_name, uint_max, test_var);
    5204           0 :                                 return -1;
    5205             :                         }
    5206           0 :                         object->fSecureResponses = test_var;
    5207             :                 } else {
    5208           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    5209             :                           PyLong_Type.tp_name);
    5210           0 :                         return -1;
    5211             :                 }
    5212             :         }
    5213           0 :         return 0;
    5214             : }
    5215             : 
    5216           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_fRoundRobin(PyObject *obj, void *closure)
    5217             : {
    5218           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    5219           0 :         PyObject *py_fRoundRobin;
    5220           1 :         py_fRoundRobin = PyLong_FromLong((uint16_t)(object->fRoundRobin));
    5221           1 :         return py_fRoundRobin;
    5222             : }
    5223             : 
    5224           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_fRoundRobin(PyObject *py_obj, PyObject *value, void *closure)
    5225             : {
    5226           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    5227           0 :         if (value == NULL) {
    5228           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fRoundRobin");
    5229           0 :                 return -1;
    5230             :         }
    5231             :         {
    5232           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fRoundRobin));
    5233           0 :                 if (PyLong_Check(value)) {
    5234           0 :                         unsigned long long test_var;
    5235           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    5236           0 :                         if (PyErr_Occurred() != NULL) {
    5237           0 :                                 return -1;
    5238             :                         }
    5239           0 :                         if (test_var > uint_max) {
    5240           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    5241             :                                   PyLong_Type.tp_name, uint_max, test_var);
    5242           0 :                                 return -1;
    5243             :                         }
    5244           0 :                         object->fRoundRobin = test_var;
    5245             :                 } else {
    5246           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    5247             :                           PyLong_Type.tp_name);
    5248           0 :                         return -1;
    5249             :                 }
    5250             :         }
    5251           0 :         return 0;
    5252             : }
    5253             : 
    5254           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_fLocalNetPriority(PyObject *obj, void *closure)
    5255             : {
    5256           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    5257           0 :         PyObject *py_fLocalNetPriority;
    5258           1 :         py_fLocalNetPriority = PyLong_FromLong((uint16_t)(object->fLocalNetPriority));
    5259           1 :         return py_fLocalNetPriority;
    5260             : }
    5261             : 
    5262           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_fLocalNetPriority(PyObject *py_obj, PyObject *value, void *closure)
    5263             : {
    5264           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    5265           0 :         if (value == NULL) {
    5266           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fLocalNetPriority");
    5267           0 :                 return -1;
    5268             :         }
    5269             :         {
    5270           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fLocalNetPriority));
    5271           0 :                 if (PyLong_Check(value)) {
    5272           0 :                         unsigned long long test_var;
    5273           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    5274           0 :                         if (PyErr_Occurred() != NULL) {
    5275           0 :                                 return -1;
    5276             :                         }
    5277           0 :                         if (test_var > uint_max) {
    5278           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    5279             :                                   PyLong_Type.tp_name, uint_max, test_var);
    5280           0 :                                 return -1;
    5281             :                         }
    5282           0 :                         object->fLocalNetPriority = test_var;
    5283             :                 } else {
    5284           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    5285             :                           PyLong_Type.tp_name);
    5286           0 :                         return -1;
    5287             :                 }
    5288             :         }
    5289           0 :         return 0;
    5290             : }
    5291             : 
    5292           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_fBindSecondaries(PyObject *obj, void *closure)
    5293             : {
    5294           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    5295           0 :         PyObject *py_fBindSecondaries;
    5296           1 :         py_fBindSecondaries = PyLong_FromLong((uint16_t)(object->fBindSecondaries));
    5297           1 :         return py_fBindSecondaries;
    5298             : }
    5299             : 
    5300           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_fBindSecondaries(PyObject *py_obj, PyObject *value, void *closure)
    5301             : {
    5302           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    5303           0 :         if (value == NULL) {
    5304           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fBindSecondaries");
    5305           0 :                 return -1;
    5306             :         }
    5307             :         {
    5308           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fBindSecondaries));
    5309           0 :                 if (PyLong_Check(value)) {
    5310           0 :                         unsigned long long test_var;
    5311           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    5312           0 :                         if (PyErr_Occurred() != NULL) {
    5313           0 :                                 return -1;
    5314             :                         }
    5315           0 :                         if (test_var > uint_max) {
    5316           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    5317             :                                   PyLong_Type.tp_name, uint_max, test_var);
    5318           0 :                                 return -1;
    5319             :                         }
    5320           0 :                         object->fBindSecondaries = test_var;
    5321             :                 } else {
    5322           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    5323             :                           PyLong_Type.tp_name);
    5324           0 :                         return -1;
    5325             :                 }
    5326             :         }
    5327           0 :         return 0;
    5328             : }
    5329             : 
    5330           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_fWriteAuthorityNs(PyObject *obj, void *closure)
    5331             : {
    5332           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    5333           0 :         PyObject *py_fWriteAuthorityNs;
    5334           1 :         py_fWriteAuthorityNs = PyLong_FromLong((uint16_t)(object->fWriteAuthorityNs));
    5335           1 :         return py_fWriteAuthorityNs;
    5336             : }
    5337             : 
    5338           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_fWriteAuthorityNs(PyObject *py_obj, PyObject *value, void *closure)
    5339             : {
    5340           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    5341           0 :         if (value == NULL) {
    5342           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fWriteAuthorityNs");
    5343           0 :                 return -1;
    5344             :         }
    5345             :         {
    5346           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fWriteAuthorityNs));
    5347           0 :                 if (PyLong_Check(value)) {
    5348           0 :                         unsigned long long test_var;
    5349           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    5350           0 :                         if (PyErr_Occurred() != NULL) {
    5351           0 :                                 return -1;
    5352             :                         }
    5353           0 :                         if (test_var > uint_max) {
    5354           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    5355             :                                   PyLong_Type.tp_name, uint_max, test_var);
    5356           0 :                                 return -1;
    5357             :                         }
    5358           0 :                         object->fWriteAuthorityNs = test_var;
    5359             :                 } else {
    5360           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    5361             :                           PyLong_Type.tp_name);
    5362           0 :                         return -1;
    5363             :                 }
    5364             :         }
    5365           0 :         return 0;
    5366             : }
    5367             : 
    5368           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_fStrictFileParsing(PyObject *obj, void *closure)
    5369             : {
    5370           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    5371           0 :         PyObject *py_fStrictFileParsing;
    5372           1 :         py_fStrictFileParsing = PyLong_FromLong((uint16_t)(object->fStrictFileParsing));
    5373           1 :         return py_fStrictFileParsing;
    5374             : }
    5375             : 
    5376           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_fStrictFileParsing(PyObject *py_obj, PyObject *value, void *closure)
    5377             : {
    5378           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    5379           0 :         if (value == NULL) {
    5380           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fStrictFileParsing");
    5381           0 :                 return -1;
    5382             :         }
    5383             :         {
    5384           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fStrictFileParsing));
    5385           0 :                 if (PyLong_Check(value)) {
    5386           0 :                         unsigned long long test_var;
    5387           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    5388           0 :                         if (PyErr_Occurred() != NULL) {
    5389           0 :                                 return -1;
    5390             :                         }
    5391           0 :                         if (test_var > uint_max) {
    5392           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    5393             :                                   PyLong_Type.tp_name, uint_max, test_var);
    5394           0 :                                 return -1;
    5395             :                         }
    5396           0 :                         object->fStrictFileParsing = test_var;
    5397             :                 } else {
    5398           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    5399             :                           PyLong_Type.tp_name);
    5400           0 :                         return -1;
    5401             :                 }
    5402             :         }
    5403           0 :         return 0;
    5404             : }
    5405             : 
    5406           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_fLooseWildcarding(PyObject *obj, void *closure)
    5407             : {
    5408           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    5409           0 :         PyObject *py_fLooseWildcarding;
    5410           1 :         py_fLooseWildcarding = PyLong_FromLong((uint16_t)(object->fLooseWildcarding));
    5411           1 :         return py_fLooseWildcarding;
    5412             : }
    5413             : 
    5414           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_fLooseWildcarding(PyObject *py_obj, PyObject *value, void *closure)
    5415             : {
    5416           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    5417           0 :         if (value == NULL) {
    5418           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fLooseWildcarding");
    5419           0 :                 return -1;
    5420             :         }
    5421             :         {
    5422           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fLooseWildcarding));
    5423           0 :                 if (PyLong_Check(value)) {
    5424           0 :                         unsigned long long test_var;
    5425           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    5426           0 :                         if (PyErr_Occurred() != NULL) {
    5427           0 :                                 return -1;
    5428             :                         }
    5429           0 :                         if (test_var > uint_max) {
    5430           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    5431             :                                   PyLong_Type.tp_name, uint_max, test_var);
    5432           0 :                                 return -1;
    5433             :                         }
    5434           0 :                         object->fLooseWildcarding = test_var;
    5435             :                 } else {
    5436           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    5437             :                           PyLong_Type.tp_name);
    5438           0 :                         return -1;
    5439             :                 }
    5440             :         }
    5441           0 :         return 0;
    5442             : }
    5443             : 
    5444           1 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_fDefaultAgingState(PyObject *obj, void *closure)
    5445             : {
    5446           1 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    5447           0 :         PyObject *py_fDefaultAgingState;
    5448           1 :         py_fDefaultAgingState = PyLong_FromLong((uint16_t)(object->fDefaultAgingState));
    5449           1 :         return py_fDefaultAgingState;
    5450             : }
    5451             : 
    5452           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_fDefaultAgingState(PyObject *py_obj, PyObject *value, void *closure)
    5453             : {
    5454           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    5455           0 :         if (value == NULL) {
    5456           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fDefaultAgingState");
    5457           0 :                 return -1;
    5458             :         }
    5459             :         {
    5460           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fDefaultAgingState));
    5461           0 :                 if (PyLong_Check(value)) {
    5462           0 :                         unsigned long long test_var;
    5463           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    5464           0 :                         if (PyErr_Occurred() != NULL) {
    5465           0 :                                 return -1;
    5466             :                         }
    5467           0 :                         if (test_var > uint_max) {
    5468           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    5469             :                                   PyLong_Type.tp_name, uint_max, test_var);
    5470           0 :                                 return -1;
    5471             :                         }
    5472           0 :                         object->fDefaultAgingState = test_var;
    5473             :                 } else {
    5474           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    5475             :                           PyLong_Type.tp_name);
    5476           0 :                         return -1;
    5477             :                 }
    5478             :         }
    5479           0 :         return 0;
    5480             : }
    5481             : 
    5482           0 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_get_fReserveArray(PyObject *obj, void *closure)
    5483             : {
    5484           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(obj);
    5485           0 :         PyObject *py_fReserveArray;
    5486           0 :         py_fReserveArray = PyList_New(15);
    5487           0 :         if (py_fReserveArray == NULL) {
    5488           0 :                 return NULL;
    5489             :         }
    5490             :         {
    5491             :                 int fReserveArray_cntr_0;
    5492           0 :                 for (fReserveArray_cntr_0 = 0; fReserveArray_cntr_0 < (15); fReserveArray_cntr_0++) {
    5493           0 :                         PyObject *py_fReserveArray_0;
    5494           0 :                         py_fReserveArray_0 = PyLong_FromLong((uint16_t)((object->fReserveArray)[fReserveArray_cntr_0]));
    5495           0 :                         PyList_SetItem(py_fReserveArray, fReserveArray_cntr_0, py_fReserveArray_0);
    5496             :                 }
    5497             :         }
    5498           0 :         return py_fReserveArray;
    5499             : }
    5500             : 
    5501           0 : static int py_DNS_RPC_SERVER_INFO_W2K_set_fReserveArray(PyObject *py_obj, PyObject *value, void *closure)
    5502             : {
    5503           0 :         struct DNS_RPC_SERVER_INFO_W2K *object = pytalloc_get_ptr(py_obj);
    5504           0 :         if (value == NULL) {
    5505           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fReserveArray");
    5506           0 :                 return -1;
    5507             :         }
    5508           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
    5509             :         {
    5510           0 :                 int fReserveArray_cntr_0;
    5511           0 :                 if (ARRAY_SIZE(object->fReserveArray) != PyList_GET_SIZE(value)) {
    5512           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));
    5513           0 :                         return -1;
    5514             :                 }
    5515           0 :                 for (fReserveArray_cntr_0 = 0; fReserveArray_cntr_0 < PyList_GET_SIZE(value); fReserveArray_cntr_0++) {
    5516           0 :                         if (PyList_GET_ITEM(value, fReserveArray_cntr_0) == NULL) {
    5517           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->fReserveArray)[fReserveArray_cntr_0]");
    5518           0 :                                 return -1;
    5519             :                         }
    5520             :                         {
    5521           0 :                                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof((object->fReserveArray)[fReserveArray_cntr_0]));
    5522           0 :                                 if (PyLong_Check(PyList_GET_ITEM(value, fReserveArray_cntr_0))) {
    5523           0 :                                         unsigned long long test_var;
    5524           0 :                                         test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, fReserveArray_cntr_0));
    5525           0 :                                         if (PyErr_Occurred() != NULL) {
    5526           0 :                                                 return -1;
    5527             :                                         }
    5528           0 :                                         if (test_var > uint_max) {
    5529           0 :                                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    5530             :                                                   PyLong_Type.tp_name, uint_max, test_var);
    5531           0 :                                                 return -1;
    5532             :                                         }
    5533           0 :                                         (object->fReserveArray)[fReserveArray_cntr_0] = test_var;
    5534             :                                 } else {
    5535           0 :                                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    5536             :                                           PyLong_Type.tp_name);
    5537           0 :                                         return -1;
    5538             :                                 }
    5539             :                         }
    5540             :                 }
    5541             :         }
    5542           0 :         return 0;
    5543             : }
    5544             : 
    5545             : static PyGetSetDef py_DNS_RPC_SERVER_INFO_W2K_getsetters[] = {
    5546             :         {
    5547             :                 .name = discard_const_p(char, "dwVersion"),
    5548             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_dwVersion,
    5549             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_dwVersion,
    5550             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    5551             :         },
    5552             :         {
    5553             :                 .name = discard_const_p(char, "fBootMethod"),
    5554             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_fBootMethod,
    5555             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_fBootMethod,
    5556             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_BOOT_METHOD")
    5557             :         },
    5558             :         {
    5559             :                 .name = discard_const_p(char, "fAdminConfigured"),
    5560             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_fAdminConfigured,
    5561             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_fAdminConfigured,
    5562             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    5563             :         },
    5564             :         {
    5565             :                 .name = discard_const_p(char, "fAllowUpdate"),
    5566             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_fAllowUpdate,
    5567             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_fAllowUpdate,
    5568             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    5569             :         },
    5570             :         {
    5571             :                 .name = discard_const_p(char, "fDsAvailable"),
    5572             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_fDsAvailable,
    5573             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_fDsAvailable,
    5574             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    5575             :         },
    5576             :         {
    5577             :                 .name = discard_const_p(char, "pszServerName"),
    5578             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_pszServerName,
    5579             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_pszServerName,
    5580             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    5581             :         },
    5582             :         {
    5583             :                 .name = discard_const_p(char, "pszDsContainer"),
    5584             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_pszDsContainer,
    5585             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_pszDsContainer,
    5586             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
    5587             :         },
    5588             :         {
    5589             :                 .name = discard_const_p(char, "aipServerAddrs"),
    5590             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_aipServerAddrs,
    5591             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_aipServerAddrs,
    5592             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
    5593             :         },
    5594             :         {
    5595             :                 .name = discard_const_p(char, "aipListenAddrs"),
    5596             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_aipListenAddrs,
    5597             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_aipListenAddrs,
    5598             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
    5599             :         },
    5600             :         {
    5601             :                 .name = discard_const_p(char, "aipForwarders"),
    5602             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_aipForwarders,
    5603             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_aipForwarders,
    5604             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
    5605             :         },
    5606             :         {
    5607             :                 .name = discard_const_p(char, "pExtension1"),
    5608             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_pExtension1,
    5609             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_pExtension1,
    5610             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    5611             :         },
    5612             :         {
    5613             :                 .name = discard_const_p(char, "pExtension2"),
    5614             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_pExtension2,
    5615             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_pExtension2,
    5616             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    5617             :         },
    5618             :         {
    5619             :                 .name = discard_const_p(char, "pExtension3"),
    5620             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_pExtension3,
    5621             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_pExtension3,
    5622             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    5623             :         },
    5624             :         {
    5625             :                 .name = discard_const_p(char, "pExtension4"),
    5626             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_pExtension4,
    5627             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_pExtension4,
    5628             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    5629             :         },
    5630             :         {
    5631             :                 .name = discard_const_p(char, "pExtension5"),
    5632             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_pExtension5,
    5633             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_pExtension5,
    5634             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    5635             :         },
    5636             :         {
    5637             :                 .name = discard_const_p(char, "dwLogLevel"),
    5638             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_dwLogLevel,
    5639             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_dwLogLevel,
    5640             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    5641             :         },
    5642             :         {
    5643             :                 .name = discard_const_p(char, "dwDebugLevel"),
    5644             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_dwDebugLevel,
    5645             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_dwDebugLevel,
    5646             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    5647             :         },
    5648             :         {
    5649             :                 .name = discard_const_p(char, "dwForwardTimeout"),
    5650             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_dwForwardTimeout,
    5651             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_dwForwardTimeout,
    5652             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    5653             :         },
    5654             :         {
    5655             :                 .name = discard_const_p(char, "dwRpcProtocol"),
    5656             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_dwRpcProtocol,
    5657             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_dwRpcProtocol,
    5658             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    5659             :         },
    5660             :         {
    5661             :                 .name = discard_const_p(char, "dwNameCheckFlag"),
    5662             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_dwNameCheckFlag,
    5663             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_dwNameCheckFlag,
    5664             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_NAME_CHECK_FLAG")
    5665             :         },
    5666             :         {
    5667             :                 .name = discard_const_p(char, "cAddressAnswerLimit"),
    5668             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_cAddressAnswerLimit,
    5669             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_cAddressAnswerLimit,
    5670             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    5671             :         },
    5672             :         {
    5673             :                 .name = discard_const_p(char, "dwRecursionRetry"),
    5674             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_dwRecursionRetry,
    5675             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_dwRecursionRetry,
    5676             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    5677             :         },
    5678             :         {
    5679             :                 .name = discard_const_p(char, "dwRecursionTimeout"),
    5680             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_dwRecursionTimeout,
    5681             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_dwRecursionTimeout,
    5682             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    5683             :         },
    5684             :         {
    5685             :                 .name = discard_const_p(char, "dwMaxCacheTtl"),
    5686             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_dwMaxCacheTtl,
    5687             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_dwMaxCacheTtl,
    5688             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    5689             :         },
    5690             :         {
    5691             :                 .name = discard_const_p(char, "dwDsPollingInterval"),
    5692             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_dwDsPollingInterval,
    5693             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_dwDsPollingInterval,
    5694             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    5695             :         },
    5696             :         {
    5697             :                 .name = discard_const_p(char, "dwScavengingInterval"),
    5698             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_dwScavengingInterval,
    5699             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_dwScavengingInterval,
    5700             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    5701             :         },
    5702             :         {
    5703             :                 .name = discard_const_p(char, "dwDefaultRefreshInterval"),
    5704             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_dwDefaultRefreshInterval,
    5705             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_dwDefaultRefreshInterval,
    5706             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    5707             :         },
    5708             :         {
    5709             :                 .name = discard_const_p(char, "dwDefaultNoRefreshInterval"),
    5710             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_dwDefaultNoRefreshInterval,
    5711             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_dwDefaultNoRefreshInterval,
    5712             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    5713             :         },
    5714             :         {
    5715             :                 .name = discard_const_p(char, "dwReserveArray"),
    5716             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_dwReserveArray,
    5717             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_dwReserveArray,
    5718             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    5719             :         },
    5720             :         {
    5721             :                 .name = discard_const_p(char, "fAutoReverseZones"),
    5722             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_fAutoReverseZones,
    5723             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_fAutoReverseZones,
    5724             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    5725             :         },
    5726             :         {
    5727             :                 .name = discard_const_p(char, "fAutoCacheUpdate"),
    5728             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_fAutoCacheUpdate,
    5729             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_fAutoCacheUpdate,
    5730             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    5731             :         },
    5732             :         {
    5733             :                 .name = discard_const_p(char, "fRecurseAfterForwarding"),
    5734             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_fRecurseAfterForwarding,
    5735             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_fRecurseAfterForwarding,
    5736             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    5737             :         },
    5738             :         {
    5739             :                 .name = discard_const_p(char, "fForwardDelegations"),
    5740             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_fForwardDelegations,
    5741             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_fForwardDelegations,
    5742             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    5743             :         },
    5744             :         {
    5745             :                 .name = discard_const_p(char, "fNoRecursion"),
    5746             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_fNoRecursion,
    5747             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_fNoRecursion,
    5748             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    5749             :         },
    5750             :         {
    5751             :                 .name = discard_const_p(char, "fSecureResponses"),
    5752             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_fSecureResponses,
    5753             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_fSecureResponses,
    5754             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    5755             :         },
    5756             :         {
    5757             :                 .name = discard_const_p(char, "fRoundRobin"),
    5758             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_fRoundRobin,
    5759             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_fRoundRobin,
    5760             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    5761             :         },
    5762             :         {
    5763             :                 .name = discard_const_p(char, "fLocalNetPriority"),
    5764             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_fLocalNetPriority,
    5765             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_fLocalNetPriority,
    5766             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    5767             :         },
    5768             :         {
    5769             :                 .name = discard_const_p(char, "fBindSecondaries"),
    5770             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_fBindSecondaries,
    5771             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_fBindSecondaries,
    5772             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    5773             :         },
    5774             :         {
    5775             :                 .name = discard_const_p(char, "fWriteAuthorityNs"),
    5776             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_fWriteAuthorityNs,
    5777             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_fWriteAuthorityNs,
    5778             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    5779             :         },
    5780             :         {
    5781             :                 .name = discard_const_p(char, "fStrictFileParsing"),
    5782             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_fStrictFileParsing,
    5783             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_fStrictFileParsing,
    5784             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    5785             :         },
    5786             :         {
    5787             :                 .name = discard_const_p(char, "fLooseWildcarding"),
    5788             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_fLooseWildcarding,
    5789             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_fLooseWildcarding,
    5790             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    5791             :         },
    5792             :         {
    5793             :                 .name = discard_const_p(char, "fDefaultAgingState"),
    5794             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_fDefaultAgingState,
    5795             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_fDefaultAgingState,
    5796             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    5797             :         },
    5798             :         {
    5799             :                 .name = discard_const_p(char, "fReserveArray"),
    5800             :                 .get = py_DNS_RPC_SERVER_INFO_W2K_get_fReserveArray,
    5801             :                 .set = py_DNS_RPC_SERVER_INFO_W2K_set_fReserveArray,
    5802             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    5803             :         },
    5804             :         { .name = NULL }
    5805             : };
    5806             : 
    5807           0 : static PyObject *py_DNS_RPC_SERVER_INFO_W2K_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    5808             : {
    5809           0 :         return pytalloc_new(struct DNS_RPC_SERVER_INFO_W2K, type);
    5810             : }
    5811             : 
    5812             : 
    5813             : static PyTypeObject DNS_RPC_SERVER_INFO_W2K_Type = {
    5814             :         PyVarObject_HEAD_INIT(NULL, 0)
    5815             :         .tp_name = "dnsserver.DNS_RPC_SERVER_INFO_W2K",
    5816             :         .tp_getset = py_DNS_RPC_SERVER_INFO_W2K_getsetters,
    5817             :         .tp_methods = NULL,
    5818             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    5819             :         .tp_new = py_DNS_RPC_SERVER_INFO_W2K_new,
    5820             : };
    5821             : 
    5822             : 
    5823           0 : static PyObject *py_DNS_EXTENSION_get_extension(PyObject *obj, void *closure)
    5824             : {
    5825           0 :         struct DNS_EXTENSION *object = pytalloc_get_ptr(obj);
    5826           0 :         PyObject *py_extension;
    5827           0 :         if (object->extension == NULL) {
    5828           0 :                 Py_RETURN_NONE;
    5829             :         }
    5830           0 :         if (object->extension == NULL) {
    5831           0 :                 py_extension = Py_None;
    5832           0 :                 Py_INCREF(py_extension);
    5833             :         } else {
    5834           0 :                 if (object->extension == NULL) {
    5835           0 :                         py_extension = Py_None;
    5836           0 :                         Py_INCREF(py_extension);
    5837             :                 } else {
    5838           0 :                         py_extension = PyUnicode_Decode(object->extension, strlen(object->extension), "utf-8", "ignore");
    5839             :                 }
    5840             :         }
    5841           0 :         return py_extension;
    5842             : }
    5843             : 
    5844           0 : static int py_DNS_EXTENSION_set_extension(PyObject *py_obj, PyObject *value, void *closure)
    5845             : {
    5846           0 :         struct DNS_EXTENSION *object = pytalloc_get_ptr(py_obj);
    5847           0 :         if (value == NULL) {
    5848           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->extension");
    5849           0 :                 return -1;
    5850             :         }
    5851           0 :         if (value == Py_None) {
    5852           0 :                 object->extension = NULL;
    5853             :         } else {
    5854           0 :                 object->extension = NULL;
    5855             :                 {
    5856           0 :                         const char *test_str;
    5857           0 :                         const char *talloc_str;
    5858           0 :                         PyObject *unicode = NULL;
    5859           0 :                         if (PyUnicode_Check(value)) {
    5860           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    5861           0 :                                 if (unicode == NULL) {
    5862           0 :                                         return -1;
    5863             :                                 }
    5864           0 :                                 test_str = PyBytes_AS_STRING(unicode);
    5865           0 :                         } else if (PyBytes_Check(value)) {
    5866           0 :                                 test_str = PyBytes_AS_STRING(value);
    5867             :                         } else {
    5868           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    5869           0 :                                 return -1;
    5870             :                         }
    5871           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    5872           0 :                         if (unicode != NULL) {
    5873           0 :                                 Py_DECREF(unicode);
    5874             :                         }
    5875           0 :                         if (talloc_str == NULL) {
    5876           0 :                                 PyErr_NoMemory();
    5877           0 :                                 return -1;
    5878             :                         }
    5879           0 :                         object->extension = talloc_str;
    5880             :                 }
    5881             :         }
    5882           0 :         return 0;
    5883             : }
    5884             : 
    5885             : static PyGetSetDef py_DNS_EXTENSION_getsetters[] = {
    5886             :         {
    5887             :                 .name = discard_const_p(char, "extension"),
    5888             :                 .get = py_DNS_EXTENSION_get_extension,
    5889             :                 .set = py_DNS_EXTENSION_set_extension,
    5890             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    5891             :         },
    5892             :         { .name = NULL }
    5893             : };
    5894             : 
    5895           0 : static PyObject *py_DNS_EXTENSION_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    5896             : {
    5897           0 :         return pytalloc_new(struct DNS_EXTENSION, type);
    5898             : }
    5899             : 
    5900             : 
    5901             : static PyTypeObject DNS_EXTENSION_Type = {
    5902             :         PyVarObject_HEAD_INIT(NULL, 0)
    5903             :         .tp_name = "dnsserver.DNS_EXTENSION",
    5904             :         .tp_getset = py_DNS_EXTENSION_getsetters,
    5905             :         .tp_methods = NULL,
    5906             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    5907             :         .tp_new = py_DNS_EXTENSION_new,
    5908             : };
    5909             : 
    5910             : 
    5911           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_dwRpcStructureVersion(PyObject *obj, void *closure)
    5912             : {
    5913           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    5914           0 :         PyObject *py_dwRpcStructureVersion;
    5915           1 :         py_dwRpcStructureVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcStructureVersion));
    5916           1 :         return py_dwRpcStructureVersion;
    5917             : }
    5918             : 
    5919           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_dwRpcStructureVersion(PyObject *py_obj, PyObject *value, void *closure)
    5920             : {
    5921           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    5922           0 :         if (value == NULL) {
    5923           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcStructureVersion");
    5924           0 :                 return -1;
    5925             :         }
    5926             :         {
    5927           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcStructureVersion));
    5928           0 :                 if (PyLong_Check(value)) {
    5929           0 :                         unsigned long long test_var;
    5930           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    5931           0 :                         if (PyErr_Occurred() != NULL) {
    5932           0 :                                 return -1;
    5933             :                         }
    5934           0 :                         if (test_var > uint_max) {
    5935           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    5936             :                                   PyLong_Type.tp_name, uint_max, test_var);
    5937           0 :                                 return -1;
    5938             :                         }
    5939           0 :                         object->dwRpcStructureVersion = test_var;
    5940             :                 } else {
    5941           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    5942             :                           PyLong_Type.tp_name);
    5943           0 :                         return -1;
    5944             :                 }
    5945             :         }
    5946           0 :         return 0;
    5947             : }
    5948             : 
    5949           0 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_dwReserved0(PyObject *obj, void *closure)
    5950             : {
    5951           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    5952           0 :         PyObject *py_dwReserved0;
    5953           0 :         py_dwReserved0 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved0));
    5954           0 :         return py_dwReserved0;
    5955             : }
    5956             : 
    5957           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_dwReserved0(PyObject *py_obj, PyObject *value, void *closure)
    5958             : {
    5959           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    5960           0 :         if (value == NULL) {
    5961           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved0");
    5962           0 :                 return -1;
    5963             :         }
    5964             :         {
    5965           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved0));
    5966           0 :                 if (PyLong_Check(value)) {
    5967           0 :                         unsigned long long test_var;
    5968           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    5969           0 :                         if (PyErr_Occurred() != NULL) {
    5970           0 :                                 return -1;
    5971             :                         }
    5972           0 :                         if (test_var > uint_max) {
    5973           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    5974             :                                   PyLong_Type.tp_name, uint_max, test_var);
    5975           0 :                                 return -1;
    5976             :                         }
    5977           0 :                         object->dwReserved0 = test_var;
    5978             :                 } else {
    5979           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    5980             :                           PyLong_Type.tp_name);
    5981           0 :                         return -1;
    5982             :                 }
    5983             :         }
    5984           0 :         return 0;
    5985             : }
    5986             : 
    5987           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_dwVersion(PyObject *obj, void *closure)
    5988             : {
    5989           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    5990           0 :         PyObject *py_dwVersion;
    5991           1 :         py_dwVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwVersion));
    5992           1 :         return py_dwVersion;
    5993             : }
    5994             : 
    5995           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_dwVersion(PyObject *py_obj, PyObject *value, void *closure)
    5996             : {
    5997           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    5998           0 :         if (value == NULL) {
    5999           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwVersion");
    6000           0 :                 return -1;
    6001             :         }
    6002             :         {
    6003           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwVersion));
    6004           0 :                 if (PyLong_Check(value)) {
    6005           0 :                         unsigned long long test_var;
    6006           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    6007           0 :                         if (PyErr_Occurred() != NULL) {
    6008           0 :                                 return -1;
    6009             :                         }
    6010           0 :                         if (test_var > uint_max) {
    6011           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    6012             :                                   PyLong_Type.tp_name, uint_max, test_var);
    6013           0 :                                 return -1;
    6014             :                         }
    6015           0 :                         object->dwVersion = test_var;
    6016             :                 } else {
    6017           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    6018             :                           PyLong_Type.tp_name);
    6019           0 :                         return -1;
    6020             :                 }
    6021             :         }
    6022           0 :         return 0;
    6023             : }
    6024             : 
    6025           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_fBootMethod(PyObject *obj, void *closure)
    6026             : {
    6027           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    6028           0 :         PyObject *py_fBootMethod;
    6029           1 :         py_fBootMethod = PyLong_FromLong((uint16_t)(object->fBootMethod));
    6030           1 :         return py_fBootMethod;
    6031             : }
    6032             : 
    6033           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_fBootMethod(PyObject *py_obj, PyObject *value, void *closure)
    6034             : {
    6035           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    6036           0 :         if (value == NULL) {
    6037           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fBootMethod");
    6038           0 :                 return -1;
    6039             :         }
    6040             :         {
    6041           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fBootMethod));
    6042           0 :                 if (PyLong_Check(value)) {
    6043           0 :                         unsigned long long test_var;
    6044           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    6045           0 :                         if (PyErr_Occurred() != NULL) {
    6046           0 :                                 return -1;
    6047             :                         }
    6048           0 :                         if (test_var > uint_max) {
    6049           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    6050             :                                   PyLong_Type.tp_name, uint_max, test_var);
    6051           0 :                                 return -1;
    6052             :                         }
    6053           0 :                         object->fBootMethod = test_var;
    6054             :                 } else {
    6055           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    6056             :                           PyLong_Type.tp_name);
    6057           0 :                         return -1;
    6058             :                 }
    6059             :         }
    6060           0 :         return 0;
    6061             : }
    6062             : 
    6063           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_fAdminConfigured(PyObject *obj, void *closure)
    6064             : {
    6065           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    6066           0 :         PyObject *py_fAdminConfigured;
    6067           1 :         py_fAdminConfigured = PyLong_FromLong((uint16_t)(object->fAdminConfigured));
    6068           1 :         return py_fAdminConfigured;
    6069             : }
    6070             : 
    6071           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_fAdminConfigured(PyObject *py_obj, PyObject *value, void *closure)
    6072             : {
    6073           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    6074           0 :         if (value == NULL) {
    6075           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAdminConfigured");
    6076           0 :                 return -1;
    6077             :         }
    6078             :         {
    6079           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAdminConfigured));
    6080           0 :                 if (PyLong_Check(value)) {
    6081           0 :                         unsigned long long test_var;
    6082           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    6083           0 :                         if (PyErr_Occurred() != NULL) {
    6084           0 :                                 return -1;
    6085             :                         }
    6086           0 :                         if (test_var > uint_max) {
    6087           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    6088             :                                   PyLong_Type.tp_name, uint_max, test_var);
    6089           0 :                                 return -1;
    6090             :                         }
    6091           0 :                         object->fAdminConfigured = test_var;
    6092             :                 } else {
    6093           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    6094             :                           PyLong_Type.tp_name);
    6095           0 :                         return -1;
    6096             :                 }
    6097             :         }
    6098           0 :         return 0;
    6099             : }
    6100             : 
    6101           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_fAllowUpdate(PyObject *obj, void *closure)
    6102             : {
    6103           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    6104           0 :         PyObject *py_fAllowUpdate;
    6105           1 :         py_fAllowUpdate = PyLong_FromLong((uint16_t)(object->fAllowUpdate));
    6106           1 :         return py_fAllowUpdate;
    6107             : }
    6108             : 
    6109           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_fAllowUpdate(PyObject *py_obj, PyObject *value, void *closure)
    6110             : {
    6111           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    6112           0 :         if (value == NULL) {
    6113           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAllowUpdate");
    6114           0 :                 return -1;
    6115             :         }
    6116             :         {
    6117           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAllowUpdate));
    6118           0 :                 if (PyLong_Check(value)) {
    6119           0 :                         unsigned long long test_var;
    6120           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    6121           0 :                         if (PyErr_Occurred() != NULL) {
    6122           0 :                                 return -1;
    6123             :                         }
    6124           0 :                         if (test_var > uint_max) {
    6125           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    6126             :                                   PyLong_Type.tp_name, uint_max, test_var);
    6127           0 :                                 return -1;
    6128             :                         }
    6129           0 :                         object->fAllowUpdate = test_var;
    6130             :                 } else {
    6131           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    6132             :                           PyLong_Type.tp_name);
    6133           0 :                         return -1;
    6134             :                 }
    6135             :         }
    6136           0 :         return 0;
    6137             : }
    6138             : 
    6139           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_fDsAvailable(PyObject *obj, void *closure)
    6140             : {
    6141           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    6142           0 :         PyObject *py_fDsAvailable;
    6143           1 :         py_fDsAvailable = PyLong_FromLong((uint16_t)(object->fDsAvailable));
    6144           1 :         return py_fDsAvailable;
    6145             : }
    6146             : 
    6147           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_fDsAvailable(PyObject *py_obj, PyObject *value, void *closure)
    6148             : {
    6149           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    6150           0 :         if (value == NULL) {
    6151           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fDsAvailable");
    6152           0 :                 return -1;
    6153             :         }
    6154             :         {
    6155           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fDsAvailable));
    6156           0 :                 if (PyLong_Check(value)) {
    6157           0 :                         unsigned long long test_var;
    6158           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    6159           0 :                         if (PyErr_Occurred() != NULL) {
    6160           0 :                                 return -1;
    6161             :                         }
    6162           0 :                         if (test_var > uint_max) {
    6163           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    6164             :                                   PyLong_Type.tp_name, uint_max, test_var);
    6165           0 :                                 return -1;
    6166             :                         }
    6167           0 :                         object->fDsAvailable = test_var;
    6168             :                 } else {
    6169           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    6170             :                           PyLong_Type.tp_name);
    6171           0 :                         return -1;
    6172             :                 }
    6173             :         }
    6174           0 :         return 0;
    6175             : }
    6176             : 
    6177           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_pszServerName(PyObject *obj, void *closure)
    6178             : {
    6179           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    6180           0 :         PyObject *py_pszServerName;
    6181           1 :         if (object->pszServerName == NULL) {
    6182           0 :                 Py_RETURN_NONE;
    6183             :         }
    6184           1 :         if (object->pszServerName == NULL) {
    6185           0 :                 py_pszServerName = Py_None;
    6186           0 :                 Py_INCREF(py_pszServerName);
    6187             :         } else {
    6188           1 :                 if (object->pszServerName == NULL) {
    6189           0 :                         py_pszServerName = Py_None;
    6190           0 :                         Py_INCREF(py_pszServerName);
    6191             :                 } else {
    6192           1 :                         py_pszServerName = PyUnicode_Decode(object->pszServerName, strlen(object->pszServerName), "utf-8", "ignore");
    6193             :                 }
    6194             :         }
    6195           1 :         return py_pszServerName;
    6196             : }
    6197             : 
    6198           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_pszServerName(PyObject *py_obj, PyObject *value, void *closure)
    6199             : {
    6200           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    6201           0 :         if (value == NULL) {
    6202           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszServerName");
    6203           0 :                 return -1;
    6204             :         }
    6205           0 :         if (value == Py_None) {
    6206           0 :                 object->pszServerName = NULL;
    6207             :         } else {
    6208           0 :                 object->pszServerName = NULL;
    6209             :                 {
    6210           0 :                         const char *test_str;
    6211           0 :                         const char *talloc_str;
    6212           0 :                         PyObject *unicode = NULL;
    6213           0 :                         if (PyUnicode_Check(value)) {
    6214           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    6215           0 :                                 if (unicode == NULL) {
    6216           0 :                                         return -1;
    6217             :                                 }
    6218           0 :                                 test_str = PyBytes_AS_STRING(unicode);
    6219           0 :                         } else if (PyBytes_Check(value)) {
    6220           0 :                                 test_str = PyBytes_AS_STRING(value);
    6221             :                         } else {
    6222           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    6223           0 :                                 return -1;
    6224             :                         }
    6225           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    6226           0 :                         if (unicode != NULL) {
    6227           0 :                                 Py_DECREF(unicode);
    6228             :                         }
    6229           0 :                         if (talloc_str == NULL) {
    6230           0 :                                 PyErr_NoMemory();
    6231           0 :                                 return -1;
    6232             :                         }
    6233           0 :                         object->pszServerName = talloc_str;
    6234             :                 }
    6235             :         }
    6236           0 :         return 0;
    6237             : }
    6238             : 
    6239           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_pszDsContainer(PyObject *obj, void *closure)
    6240             : {
    6241           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    6242           0 :         PyObject *py_pszDsContainer;
    6243           1 :         if (object->pszDsContainer == NULL) {
    6244           0 :                 Py_RETURN_NONE;
    6245             :         }
    6246           1 :         if (object->pszDsContainer == NULL) {
    6247           0 :                 py_pszDsContainer = Py_None;
    6248           0 :                 Py_INCREF(py_pszDsContainer);
    6249             :         } else {
    6250           1 :                 if (object->pszDsContainer == NULL) {
    6251           0 :                         py_pszDsContainer = Py_None;
    6252           0 :                         Py_INCREF(py_pszDsContainer);
    6253             :                 } else {
    6254           1 :                         py_pszDsContainer = PyUnicode_Decode(object->pszDsContainer, strlen(object->pszDsContainer), "utf-8", "ignore");
    6255             :                 }
    6256             :         }
    6257           1 :         return py_pszDsContainer;
    6258             : }
    6259             : 
    6260           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_pszDsContainer(PyObject *py_obj, PyObject *value, void *closure)
    6261             : {
    6262           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    6263           0 :         if (value == NULL) {
    6264           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszDsContainer");
    6265           0 :                 return -1;
    6266             :         }
    6267           0 :         if (value == Py_None) {
    6268           0 :                 object->pszDsContainer = NULL;
    6269             :         } else {
    6270           0 :                 object->pszDsContainer = NULL;
    6271             :                 {
    6272           0 :                         const char *test_str;
    6273           0 :                         const char *talloc_str;
    6274           0 :                         PyObject *unicode = NULL;
    6275           0 :                         if (PyUnicode_Check(value)) {
    6276           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    6277           0 :                                 if (unicode == NULL) {
    6278           0 :                                         return -1;
    6279             :                                 }
    6280           0 :                                 test_str = PyBytes_AS_STRING(unicode);
    6281           0 :                         } else if (PyBytes_Check(value)) {
    6282           0 :                                 test_str = PyBytes_AS_STRING(value);
    6283             :                         } else {
    6284           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    6285           0 :                                 return -1;
    6286             :                         }
    6287           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    6288           0 :                         if (unicode != NULL) {
    6289           0 :                                 Py_DECREF(unicode);
    6290             :                         }
    6291           0 :                         if (talloc_str == NULL) {
    6292           0 :                                 PyErr_NoMemory();
    6293           0 :                                 return -1;
    6294             :                         }
    6295           0 :                         object->pszDsContainer = talloc_str;
    6296             :                 }
    6297             :         }
    6298           0 :         return 0;
    6299             : }
    6300             : 
    6301           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_aipServerAddrs(PyObject *obj, void *closure)
    6302             : {
    6303           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    6304           0 :         PyObject *py_aipServerAddrs;
    6305           1 :         if (object->aipServerAddrs == NULL) {
    6306           0 :                 Py_RETURN_NONE;
    6307             :         }
    6308           1 :         if (object->aipServerAddrs == NULL) {
    6309           0 :                 py_aipServerAddrs = Py_None;
    6310           0 :                 Py_INCREF(py_aipServerAddrs);
    6311             :         } else {
    6312           1 :                 py_aipServerAddrs = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipServerAddrs, object->aipServerAddrs);
    6313             :         }
    6314           1 :         return py_aipServerAddrs;
    6315             : }
    6316             : 
    6317           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_aipServerAddrs(PyObject *py_obj, PyObject *value, void *closure)
    6318             : {
    6319           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    6320           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipServerAddrs));
    6321           0 :         if (value == NULL) {
    6322           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipServerAddrs");
    6323           0 :                 return -1;
    6324             :         }
    6325           0 :         if (value == Py_None) {
    6326           0 :                 object->aipServerAddrs = NULL;
    6327             :         } else {
    6328           0 :                 object->aipServerAddrs = NULL;
    6329           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
    6330           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    6331           0 :                         PyErr_NoMemory();
    6332           0 :                         return -1;
    6333             :                 }
    6334           0 :                 object->aipServerAddrs = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
    6335             :         }
    6336           0 :         return 0;
    6337             : }
    6338             : 
    6339           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_aipListenAddrs(PyObject *obj, void *closure)
    6340             : {
    6341           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    6342           0 :         PyObject *py_aipListenAddrs;
    6343           1 :         if (object->aipListenAddrs == NULL) {
    6344           0 :                 Py_RETURN_NONE;
    6345             :         }
    6346           1 :         if (object->aipListenAddrs == NULL) {
    6347           0 :                 py_aipListenAddrs = Py_None;
    6348           0 :                 Py_INCREF(py_aipListenAddrs);
    6349             :         } else {
    6350           1 :                 py_aipListenAddrs = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipListenAddrs, object->aipListenAddrs);
    6351             :         }
    6352           1 :         return py_aipListenAddrs;
    6353             : }
    6354             : 
    6355           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_aipListenAddrs(PyObject *py_obj, PyObject *value, void *closure)
    6356             : {
    6357           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    6358           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipListenAddrs));
    6359           0 :         if (value == NULL) {
    6360           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipListenAddrs");
    6361           0 :                 return -1;
    6362             :         }
    6363           0 :         if (value == Py_None) {
    6364           0 :                 object->aipListenAddrs = NULL;
    6365             :         } else {
    6366           0 :                 object->aipListenAddrs = NULL;
    6367           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
    6368           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    6369           0 :                         PyErr_NoMemory();
    6370           0 :                         return -1;
    6371             :                 }
    6372           0 :                 object->aipListenAddrs = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
    6373             :         }
    6374           0 :         return 0;
    6375             : }
    6376             : 
    6377           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_aipForwarders(PyObject *obj, void *closure)
    6378             : {
    6379           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    6380           0 :         PyObject *py_aipForwarders;
    6381           1 :         if (object->aipForwarders == NULL) {
    6382           1 :                 Py_RETURN_NONE;
    6383             :         }
    6384           0 :         if (object->aipForwarders == NULL) {
    6385           0 :                 py_aipForwarders = Py_None;
    6386           0 :                 Py_INCREF(py_aipForwarders);
    6387             :         } else {
    6388           0 :                 py_aipForwarders = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipForwarders, object->aipForwarders);
    6389             :         }
    6390           0 :         return py_aipForwarders;
    6391             : }
    6392             : 
    6393           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_aipForwarders(PyObject *py_obj, PyObject *value, void *closure)
    6394             : {
    6395           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    6396           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipForwarders));
    6397           0 :         if (value == NULL) {
    6398           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipForwarders");
    6399           0 :                 return -1;
    6400             :         }
    6401           0 :         if (value == Py_None) {
    6402           0 :                 object->aipForwarders = NULL;
    6403             :         } else {
    6404           0 :                 object->aipForwarders = NULL;
    6405           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
    6406           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    6407           0 :                         PyErr_NoMemory();
    6408           0 :                         return -1;
    6409             :                 }
    6410           0 :                 object->aipForwarders = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
    6411             :         }
    6412           0 :         return 0;
    6413             : }
    6414             : 
    6415           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_aipLogFilter(PyObject *obj, void *closure)
    6416             : {
    6417           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    6418           0 :         PyObject *py_aipLogFilter;
    6419           1 :         if (object->aipLogFilter == NULL) {
    6420           1 :                 Py_RETURN_NONE;
    6421             :         }
    6422           0 :         if (object->aipLogFilter == NULL) {
    6423           0 :                 py_aipLogFilter = Py_None;
    6424           0 :                 Py_INCREF(py_aipLogFilter);
    6425             :         } else {
    6426           0 :                 py_aipLogFilter = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipLogFilter, object->aipLogFilter);
    6427             :         }
    6428           0 :         return py_aipLogFilter;
    6429             : }
    6430             : 
    6431           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_aipLogFilter(PyObject *py_obj, PyObject *value, void *closure)
    6432             : {
    6433           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    6434           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipLogFilter));
    6435           0 :         if (value == NULL) {
    6436           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipLogFilter");
    6437           0 :                 return -1;
    6438             :         }
    6439           0 :         if (value == Py_None) {
    6440           0 :                 object->aipLogFilter = NULL;
    6441             :         } else {
    6442           0 :                 object->aipLogFilter = NULL;
    6443           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
    6444           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    6445           0 :                         PyErr_NoMemory();
    6446           0 :                         return -1;
    6447             :                 }
    6448           0 :                 object->aipLogFilter = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
    6449             :         }
    6450           0 :         return 0;
    6451             : }
    6452             : 
    6453           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_pwszLogFilePath(PyObject *obj, void *closure)
    6454             : {
    6455           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    6456           0 :         PyObject *py_pwszLogFilePath;
    6457           1 :         if (object->pwszLogFilePath == NULL) {
    6458           1 :                 Py_RETURN_NONE;
    6459             :         }
    6460           0 :         if (object->pwszLogFilePath == NULL) {
    6461           0 :                 py_pwszLogFilePath = Py_None;
    6462           0 :                 Py_INCREF(py_pwszLogFilePath);
    6463             :         } else {
    6464           0 :                 if (object->pwszLogFilePath == NULL) {
    6465           0 :                         py_pwszLogFilePath = Py_None;
    6466           0 :                         Py_INCREF(py_pwszLogFilePath);
    6467             :                 } else {
    6468           0 :                         py_pwszLogFilePath = PyUnicode_Decode(object->pwszLogFilePath, strlen(object->pwszLogFilePath), "utf-8", "ignore");
    6469             :                 }
    6470             :         }
    6471           0 :         return py_pwszLogFilePath;
    6472             : }
    6473             : 
    6474           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_pwszLogFilePath(PyObject *py_obj, PyObject *value, void *closure)
    6475             : {
    6476           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    6477           0 :         if (value == NULL) {
    6478           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pwszLogFilePath");
    6479           0 :                 return -1;
    6480             :         }
    6481           0 :         if (value == Py_None) {
    6482           0 :                 object->pwszLogFilePath = NULL;
    6483             :         } else {
    6484           0 :                 object->pwszLogFilePath = NULL;
    6485             :                 {
    6486           0 :                         const char *test_str;
    6487           0 :                         const char *talloc_str;
    6488           0 :                         PyObject *unicode = NULL;
    6489           0 :                         if (PyUnicode_Check(value)) {
    6490           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    6491           0 :                                 if (unicode == NULL) {
    6492           0 :                                         return -1;
    6493             :                                 }
    6494           0 :                                 test_str = PyBytes_AS_STRING(unicode);
    6495           0 :                         } else if (PyBytes_Check(value)) {
    6496           0 :                                 test_str = PyBytes_AS_STRING(value);
    6497             :                         } else {
    6498           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    6499           0 :                                 return -1;
    6500             :                         }
    6501           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    6502           0 :                         if (unicode != NULL) {
    6503           0 :                                 Py_DECREF(unicode);
    6504             :                         }
    6505           0 :                         if (talloc_str == NULL) {
    6506           0 :                                 PyErr_NoMemory();
    6507           0 :                                 return -1;
    6508             :                         }
    6509           0 :                         object->pwszLogFilePath = talloc_str;
    6510             :                 }
    6511             :         }
    6512           0 :         return 0;
    6513             : }
    6514             : 
    6515           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_pszDomainName(PyObject *obj, void *closure)
    6516             : {
    6517           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    6518           0 :         PyObject *py_pszDomainName;
    6519           1 :         if (object->pszDomainName == NULL) {
    6520           0 :                 Py_RETURN_NONE;
    6521             :         }
    6522           1 :         if (object->pszDomainName == NULL) {
    6523           0 :                 py_pszDomainName = Py_None;
    6524           0 :                 Py_INCREF(py_pszDomainName);
    6525             :         } else {
    6526           1 :                 if (object->pszDomainName == NULL) {
    6527           0 :                         py_pszDomainName = Py_None;
    6528           0 :                         Py_INCREF(py_pszDomainName);
    6529             :                 } else {
    6530           1 :                         py_pszDomainName = PyUnicode_Decode(object->pszDomainName, strlen(object->pszDomainName), "utf-8", "ignore");
    6531             :                 }
    6532             :         }
    6533           1 :         return py_pszDomainName;
    6534             : }
    6535             : 
    6536           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_pszDomainName(PyObject *py_obj, PyObject *value, void *closure)
    6537             : {
    6538           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    6539           0 :         if (value == NULL) {
    6540           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszDomainName");
    6541           0 :                 return -1;
    6542             :         }
    6543           0 :         if (value == Py_None) {
    6544           0 :                 object->pszDomainName = NULL;
    6545             :         } else {
    6546           0 :                 object->pszDomainName = NULL;
    6547             :                 {
    6548           0 :                         const char *test_str;
    6549           0 :                         const char *talloc_str;
    6550           0 :                         PyObject *unicode = NULL;
    6551           0 :                         if (PyUnicode_Check(value)) {
    6552           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    6553           0 :                                 if (unicode == NULL) {
    6554           0 :                                         return -1;
    6555             :                                 }
    6556           0 :                                 test_str = PyBytes_AS_STRING(unicode);
    6557           0 :                         } else if (PyBytes_Check(value)) {
    6558           0 :                                 test_str = PyBytes_AS_STRING(value);
    6559             :                         } else {
    6560           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    6561           0 :                                 return -1;
    6562             :                         }
    6563           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    6564           0 :                         if (unicode != NULL) {
    6565           0 :                                 Py_DECREF(unicode);
    6566             :                         }
    6567           0 :                         if (talloc_str == NULL) {
    6568           0 :                                 PyErr_NoMemory();
    6569           0 :                                 return -1;
    6570             :                         }
    6571           0 :                         object->pszDomainName = talloc_str;
    6572             :                 }
    6573             :         }
    6574           0 :         return 0;
    6575             : }
    6576             : 
    6577           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_pszForestName(PyObject *obj, void *closure)
    6578             : {
    6579           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    6580           0 :         PyObject *py_pszForestName;
    6581           1 :         if (object->pszForestName == NULL) {
    6582           0 :                 Py_RETURN_NONE;
    6583             :         }
    6584           1 :         if (object->pszForestName == NULL) {
    6585           0 :                 py_pszForestName = Py_None;
    6586           0 :                 Py_INCREF(py_pszForestName);
    6587             :         } else {
    6588           1 :                 if (object->pszForestName == NULL) {
    6589           0 :                         py_pszForestName = Py_None;
    6590           0 :                         Py_INCREF(py_pszForestName);
    6591             :                 } else {
    6592           1 :                         py_pszForestName = PyUnicode_Decode(object->pszForestName, strlen(object->pszForestName), "utf-8", "ignore");
    6593             :                 }
    6594             :         }
    6595           1 :         return py_pszForestName;
    6596             : }
    6597             : 
    6598           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_pszForestName(PyObject *py_obj, PyObject *value, void *closure)
    6599             : {
    6600           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    6601           0 :         if (value == NULL) {
    6602           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszForestName");
    6603           0 :                 return -1;
    6604             :         }
    6605           0 :         if (value == Py_None) {
    6606           0 :                 object->pszForestName = NULL;
    6607             :         } else {
    6608           0 :                 object->pszForestName = NULL;
    6609             :                 {
    6610           0 :                         const char *test_str;
    6611           0 :                         const char *talloc_str;
    6612           0 :                         PyObject *unicode = NULL;
    6613           0 :                         if (PyUnicode_Check(value)) {
    6614           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    6615           0 :                                 if (unicode == NULL) {
    6616           0 :                                         return -1;
    6617             :                                 }
    6618           0 :                                 test_str = PyBytes_AS_STRING(unicode);
    6619           0 :                         } else if (PyBytes_Check(value)) {
    6620           0 :                                 test_str = PyBytes_AS_STRING(value);
    6621             :                         } else {
    6622           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    6623           0 :                                 return -1;
    6624             :                         }
    6625           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    6626           0 :                         if (unicode != NULL) {
    6627           0 :                                 Py_DECREF(unicode);
    6628             :                         }
    6629           0 :                         if (talloc_str == NULL) {
    6630           0 :                                 PyErr_NoMemory();
    6631           0 :                                 return -1;
    6632             :                         }
    6633           0 :                         object->pszForestName = talloc_str;
    6634             :                 }
    6635             :         }
    6636           0 :         return 0;
    6637             : }
    6638             : 
    6639           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_pszDomainDirectoryPartition(PyObject *obj, void *closure)
    6640             : {
    6641           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    6642           0 :         PyObject *py_pszDomainDirectoryPartition;
    6643           1 :         if (object->pszDomainDirectoryPartition == NULL) {
    6644           0 :                 Py_RETURN_NONE;
    6645             :         }
    6646           1 :         if (object->pszDomainDirectoryPartition == NULL) {
    6647           0 :                 py_pszDomainDirectoryPartition = Py_None;
    6648           0 :                 Py_INCREF(py_pszDomainDirectoryPartition);
    6649             :         } else {
    6650           1 :                 if (object->pszDomainDirectoryPartition == NULL) {
    6651           0 :                         py_pszDomainDirectoryPartition = Py_None;
    6652           0 :                         Py_INCREF(py_pszDomainDirectoryPartition);
    6653             :                 } else {
    6654           1 :                         py_pszDomainDirectoryPartition = PyUnicode_Decode(object->pszDomainDirectoryPartition, strlen(object->pszDomainDirectoryPartition), "utf-8", "ignore");
    6655             :                 }
    6656             :         }
    6657           1 :         return py_pszDomainDirectoryPartition;
    6658             : }
    6659             : 
    6660           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_pszDomainDirectoryPartition(PyObject *py_obj, PyObject *value, void *closure)
    6661             : {
    6662           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    6663           0 :         if (value == NULL) {
    6664           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszDomainDirectoryPartition");
    6665           0 :                 return -1;
    6666             :         }
    6667           0 :         if (value == Py_None) {
    6668           0 :                 object->pszDomainDirectoryPartition = NULL;
    6669             :         } else {
    6670           0 :                 object->pszDomainDirectoryPartition = NULL;
    6671             :                 {
    6672           0 :                         const char *test_str;
    6673           0 :                         const char *talloc_str;
    6674           0 :                         PyObject *unicode = NULL;
    6675           0 :                         if (PyUnicode_Check(value)) {
    6676           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    6677           0 :                                 if (unicode == NULL) {
    6678           0 :                                         return -1;
    6679             :                                 }
    6680           0 :                                 test_str = PyBytes_AS_STRING(unicode);
    6681           0 :                         } else if (PyBytes_Check(value)) {
    6682           0 :                                 test_str = PyBytes_AS_STRING(value);
    6683             :                         } else {
    6684           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    6685           0 :                                 return -1;
    6686             :                         }
    6687           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    6688           0 :                         if (unicode != NULL) {
    6689           0 :                                 Py_DECREF(unicode);
    6690             :                         }
    6691           0 :                         if (talloc_str == NULL) {
    6692           0 :                                 PyErr_NoMemory();
    6693           0 :                                 return -1;
    6694             :                         }
    6695           0 :                         object->pszDomainDirectoryPartition = talloc_str;
    6696             :                 }
    6697             :         }
    6698           0 :         return 0;
    6699             : }
    6700             : 
    6701           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_pszForestDirectoryPartition(PyObject *obj, void *closure)
    6702             : {
    6703           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    6704           0 :         PyObject *py_pszForestDirectoryPartition;
    6705           1 :         if (object->pszForestDirectoryPartition == NULL) {
    6706           0 :                 Py_RETURN_NONE;
    6707             :         }
    6708           1 :         if (object->pszForestDirectoryPartition == NULL) {
    6709           0 :                 py_pszForestDirectoryPartition = Py_None;
    6710           0 :                 Py_INCREF(py_pszForestDirectoryPartition);
    6711             :         } else {
    6712           1 :                 if (object->pszForestDirectoryPartition == NULL) {
    6713           0 :                         py_pszForestDirectoryPartition = Py_None;
    6714           0 :                         Py_INCREF(py_pszForestDirectoryPartition);
    6715             :                 } else {
    6716           1 :                         py_pszForestDirectoryPartition = PyUnicode_Decode(object->pszForestDirectoryPartition, strlen(object->pszForestDirectoryPartition), "utf-8", "ignore");
    6717             :                 }
    6718             :         }
    6719           1 :         return py_pszForestDirectoryPartition;
    6720             : }
    6721             : 
    6722           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_pszForestDirectoryPartition(PyObject *py_obj, PyObject *value, void *closure)
    6723             : {
    6724           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    6725           0 :         if (value == NULL) {
    6726           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszForestDirectoryPartition");
    6727           0 :                 return -1;
    6728             :         }
    6729           0 :         if (value == Py_None) {
    6730           0 :                 object->pszForestDirectoryPartition = NULL;
    6731             :         } else {
    6732           0 :                 object->pszForestDirectoryPartition = NULL;
    6733             :                 {
    6734           0 :                         const char *test_str;
    6735           0 :                         const char *talloc_str;
    6736           0 :                         PyObject *unicode = NULL;
    6737           0 :                         if (PyUnicode_Check(value)) {
    6738           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    6739           0 :                                 if (unicode == NULL) {
    6740           0 :                                         return -1;
    6741             :                                 }
    6742           0 :                                 test_str = PyBytes_AS_STRING(unicode);
    6743           0 :                         } else if (PyBytes_Check(value)) {
    6744           0 :                                 test_str = PyBytes_AS_STRING(value);
    6745             :                         } else {
    6746           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    6747           0 :                                 return -1;
    6748             :                         }
    6749           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    6750           0 :                         if (unicode != NULL) {
    6751           0 :                                 Py_DECREF(unicode);
    6752             :                         }
    6753           0 :                         if (talloc_str == NULL) {
    6754           0 :                                 PyErr_NoMemory();
    6755           0 :                                 return -1;
    6756             :                         }
    6757           0 :                         object->pszForestDirectoryPartition = talloc_str;
    6758             :                 }
    6759             :         }
    6760           0 :         return 0;
    6761             : }
    6762             : 
    6763           0 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_pExtensions(PyObject *obj, void *closure)
    6764             : {
    6765           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    6766           0 :         PyObject *py_pExtensions;
    6767           0 :         py_pExtensions = PyList_New(6);
    6768           0 :         if (py_pExtensions == NULL) {
    6769           0 :                 return NULL;
    6770             :         }
    6771             :         {
    6772             :                 int pExtensions_cntr_0;
    6773           0 :                 for (pExtensions_cntr_0 = 0; pExtensions_cntr_0 < (6); pExtensions_cntr_0++) {
    6774           0 :                         PyObject *py_pExtensions_0;
    6775           0 :                         py_pExtensions_0 = pytalloc_reference_ex(&DNS_EXTENSION_Type, pytalloc_get_mem_ctx(obj), &(object->pExtensions)[pExtensions_cntr_0]);
    6776           0 :                         PyList_SetItem(py_pExtensions, pExtensions_cntr_0, py_pExtensions_0);
    6777             :                 }
    6778             :         }
    6779           0 :         return py_pExtensions;
    6780             : }
    6781             : 
    6782           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_pExtensions(PyObject *py_obj, PyObject *value, void *closure)
    6783             : {
    6784           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    6785           0 :         if (value == NULL) {
    6786           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pExtensions");
    6787           0 :                 return -1;
    6788             :         }
    6789           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
    6790             :         {
    6791           0 :                 int pExtensions_cntr_0;
    6792           0 :                 if (ARRAY_SIZE(object->pExtensions) != PyList_GET_SIZE(value)) {
    6793           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));
    6794           0 :                         return -1;
    6795             :                 }
    6796           0 :                 for (pExtensions_cntr_0 = 0; pExtensions_cntr_0 < PyList_GET_SIZE(value); pExtensions_cntr_0++) {
    6797           0 :                         if (PyList_GET_ITEM(value, pExtensions_cntr_0) == NULL) {
    6798           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->pExtensions)[pExtensions_cntr_0]");
    6799           0 :                                 return -1;
    6800             :                         }
    6801           0 :                         PY_CHECK_TYPE(&DNS_EXTENSION_Type, PyList_GET_ITEM(value, pExtensions_cntr_0), return -1;);
    6802           0 :                         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(PyList_GET_ITEM(value, pExtensions_cntr_0))) == NULL) {
    6803           0 :                                 PyErr_NoMemory();
    6804           0 :                                 return -1;
    6805             :                         }
    6806           0 :                         (object->pExtensions)[pExtensions_cntr_0] = *(struct DNS_EXTENSION *)pytalloc_get_ptr(PyList_GET_ITEM(value, pExtensions_cntr_0));
    6807             :                 }
    6808             :         }
    6809           0 :         return 0;
    6810             : }
    6811             : 
    6812           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_dwLogLevel(PyObject *obj, void *closure)
    6813             : {
    6814           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    6815           0 :         PyObject *py_dwLogLevel;
    6816           1 :         py_dwLogLevel = PyLong_FromUnsignedLongLong((uint32_t)(object->dwLogLevel));
    6817           1 :         return py_dwLogLevel;
    6818             : }
    6819             : 
    6820           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_dwLogLevel(PyObject *py_obj, PyObject *value, void *closure)
    6821             : {
    6822           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    6823           0 :         if (value == NULL) {
    6824           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwLogLevel");
    6825           0 :                 return -1;
    6826             :         }
    6827             :         {
    6828           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwLogLevel));
    6829           0 :                 if (PyLong_Check(value)) {
    6830           0 :                         unsigned long long test_var;
    6831           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    6832           0 :                         if (PyErr_Occurred() != NULL) {
    6833           0 :                                 return -1;
    6834             :                         }
    6835           0 :                         if (test_var > uint_max) {
    6836           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    6837             :                                   PyLong_Type.tp_name, uint_max, test_var);
    6838           0 :                                 return -1;
    6839             :                         }
    6840           0 :                         object->dwLogLevel = test_var;
    6841             :                 } else {
    6842           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    6843             :                           PyLong_Type.tp_name);
    6844           0 :                         return -1;
    6845             :                 }
    6846             :         }
    6847           0 :         return 0;
    6848             : }
    6849             : 
    6850           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_dwDebugLevel(PyObject *obj, void *closure)
    6851             : {
    6852           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    6853           0 :         PyObject *py_dwDebugLevel;
    6854           1 :         py_dwDebugLevel = PyLong_FromUnsignedLongLong((uint32_t)(object->dwDebugLevel));
    6855           1 :         return py_dwDebugLevel;
    6856             : }
    6857             : 
    6858           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_dwDebugLevel(PyObject *py_obj, PyObject *value, void *closure)
    6859             : {
    6860           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    6861           0 :         if (value == NULL) {
    6862           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwDebugLevel");
    6863           0 :                 return -1;
    6864             :         }
    6865             :         {
    6866           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwDebugLevel));
    6867           0 :                 if (PyLong_Check(value)) {
    6868           0 :                         unsigned long long test_var;
    6869           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    6870           0 :                         if (PyErr_Occurred() != NULL) {
    6871           0 :                                 return -1;
    6872             :                         }
    6873           0 :                         if (test_var > uint_max) {
    6874           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    6875             :                                   PyLong_Type.tp_name, uint_max, test_var);
    6876           0 :                                 return -1;
    6877             :                         }
    6878           0 :                         object->dwDebugLevel = test_var;
    6879             :                 } else {
    6880           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    6881             :                           PyLong_Type.tp_name);
    6882           0 :                         return -1;
    6883             :                 }
    6884             :         }
    6885           0 :         return 0;
    6886             : }
    6887             : 
    6888           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_dwForwardTimeout(PyObject *obj, void *closure)
    6889             : {
    6890           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    6891           0 :         PyObject *py_dwForwardTimeout;
    6892           1 :         py_dwForwardTimeout = PyLong_FromUnsignedLongLong((uint32_t)(object->dwForwardTimeout));
    6893           1 :         return py_dwForwardTimeout;
    6894             : }
    6895             : 
    6896           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_dwForwardTimeout(PyObject *py_obj, PyObject *value, void *closure)
    6897             : {
    6898           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    6899           0 :         if (value == NULL) {
    6900           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwForwardTimeout");
    6901           0 :                 return -1;
    6902             :         }
    6903             :         {
    6904           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwForwardTimeout));
    6905           0 :                 if (PyLong_Check(value)) {
    6906           0 :                         unsigned long long test_var;
    6907           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    6908           0 :                         if (PyErr_Occurred() != NULL) {
    6909           0 :                                 return -1;
    6910             :                         }
    6911           0 :                         if (test_var > uint_max) {
    6912           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    6913             :                                   PyLong_Type.tp_name, uint_max, test_var);
    6914           0 :                                 return -1;
    6915             :                         }
    6916           0 :                         object->dwForwardTimeout = test_var;
    6917             :                 } else {
    6918           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    6919             :                           PyLong_Type.tp_name);
    6920           0 :                         return -1;
    6921             :                 }
    6922             :         }
    6923           0 :         return 0;
    6924             : }
    6925             : 
    6926           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_dwRpcProtocol(PyObject *obj, void *closure)
    6927             : {
    6928           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    6929           0 :         PyObject *py_dwRpcProtocol;
    6930           1 :         py_dwRpcProtocol = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcProtocol));
    6931           1 :         return py_dwRpcProtocol;
    6932             : }
    6933             : 
    6934           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_dwRpcProtocol(PyObject *py_obj, PyObject *value, void *closure)
    6935             : {
    6936           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    6937           0 :         if (value == NULL) {
    6938           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcProtocol");
    6939           0 :                 return -1;
    6940             :         }
    6941             :         {
    6942           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcProtocol));
    6943           0 :                 if (PyLong_Check(value)) {
    6944           0 :                         unsigned long long test_var;
    6945           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    6946           0 :                         if (PyErr_Occurred() != NULL) {
    6947           0 :                                 return -1;
    6948             :                         }
    6949           0 :                         if (test_var > uint_max) {
    6950           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    6951             :                                   PyLong_Type.tp_name, uint_max, test_var);
    6952           0 :                                 return -1;
    6953             :                         }
    6954           0 :                         object->dwRpcProtocol = test_var;
    6955             :                 } else {
    6956           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    6957             :                           PyLong_Type.tp_name);
    6958           0 :                         return -1;
    6959             :                 }
    6960             :         }
    6961           0 :         return 0;
    6962             : }
    6963             : 
    6964           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_dwNameCheckFlag(PyObject *obj, void *closure)
    6965             : {
    6966           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    6967           0 :         PyObject *py_dwNameCheckFlag;
    6968           1 :         py_dwNameCheckFlag = PyLong_FromUnsignedLongLong((uint32_t)(object->dwNameCheckFlag));
    6969           1 :         return py_dwNameCheckFlag;
    6970             : }
    6971             : 
    6972           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_dwNameCheckFlag(PyObject *py_obj, PyObject *value, void *closure)
    6973             : {
    6974           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    6975           0 :         if (value == NULL) {
    6976           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwNameCheckFlag");
    6977           0 :                 return -1;
    6978             :         }
    6979             :         {
    6980           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwNameCheckFlag));
    6981           0 :                 if (PyLong_Check(value)) {
    6982           0 :                         unsigned long long test_var;
    6983           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    6984           0 :                         if (PyErr_Occurred() != NULL) {
    6985           0 :                                 return -1;
    6986             :                         }
    6987           0 :                         if (test_var > uint_max) {
    6988           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    6989             :                                   PyLong_Type.tp_name, uint_max, test_var);
    6990           0 :                                 return -1;
    6991             :                         }
    6992           0 :                         object->dwNameCheckFlag = test_var;
    6993             :                 } else {
    6994           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    6995             :                           PyLong_Type.tp_name);
    6996           0 :                         return -1;
    6997             :                 }
    6998             :         }
    6999           0 :         return 0;
    7000             : }
    7001             : 
    7002           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_cAddressAnswerLimit(PyObject *obj, void *closure)
    7003             : {
    7004           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7005           0 :         PyObject *py_cAddressAnswerLimit;
    7006           1 :         py_cAddressAnswerLimit = PyLong_FromUnsignedLongLong((uint32_t)(object->cAddressAnswerLimit));
    7007           1 :         return py_cAddressAnswerLimit;
    7008             : }
    7009             : 
    7010           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_cAddressAnswerLimit(PyObject *py_obj, PyObject *value, void *closure)
    7011             : {
    7012           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7013           0 :         if (value == NULL) {
    7014           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->cAddressAnswerLimit");
    7015           0 :                 return -1;
    7016             :         }
    7017             :         {
    7018           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->cAddressAnswerLimit));
    7019           0 :                 if (PyLong_Check(value)) {
    7020           0 :                         unsigned long long test_var;
    7021           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7022           0 :                         if (PyErr_Occurred() != NULL) {
    7023           0 :                                 return -1;
    7024             :                         }
    7025           0 :                         if (test_var > uint_max) {
    7026           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7027             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7028           0 :                                 return -1;
    7029             :                         }
    7030           0 :                         object->cAddressAnswerLimit = test_var;
    7031             :                 } else {
    7032           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7033             :                           PyLong_Type.tp_name);
    7034           0 :                         return -1;
    7035             :                 }
    7036             :         }
    7037           0 :         return 0;
    7038             : }
    7039             : 
    7040           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_dwRecursionRetry(PyObject *obj, void *closure)
    7041             : {
    7042           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7043           0 :         PyObject *py_dwRecursionRetry;
    7044           1 :         py_dwRecursionRetry = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRecursionRetry));
    7045           1 :         return py_dwRecursionRetry;
    7046             : }
    7047             : 
    7048           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_dwRecursionRetry(PyObject *py_obj, PyObject *value, void *closure)
    7049             : {
    7050           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7051           0 :         if (value == NULL) {
    7052           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRecursionRetry");
    7053           0 :                 return -1;
    7054             :         }
    7055             :         {
    7056           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRecursionRetry));
    7057           0 :                 if (PyLong_Check(value)) {
    7058           0 :                         unsigned long long test_var;
    7059           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7060           0 :                         if (PyErr_Occurred() != NULL) {
    7061           0 :                                 return -1;
    7062             :                         }
    7063           0 :                         if (test_var > uint_max) {
    7064           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7065             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7066           0 :                                 return -1;
    7067             :                         }
    7068           0 :                         object->dwRecursionRetry = test_var;
    7069             :                 } else {
    7070           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7071             :                           PyLong_Type.tp_name);
    7072           0 :                         return -1;
    7073             :                 }
    7074             :         }
    7075           0 :         return 0;
    7076             : }
    7077             : 
    7078           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_dwRecursionTimeout(PyObject *obj, void *closure)
    7079             : {
    7080           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7081           0 :         PyObject *py_dwRecursionTimeout;
    7082           1 :         py_dwRecursionTimeout = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRecursionTimeout));
    7083           1 :         return py_dwRecursionTimeout;
    7084             : }
    7085             : 
    7086           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_dwRecursionTimeout(PyObject *py_obj, PyObject *value, void *closure)
    7087             : {
    7088           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7089           0 :         if (value == NULL) {
    7090           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRecursionTimeout");
    7091           0 :                 return -1;
    7092             :         }
    7093             :         {
    7094           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRecursionTimeout));
    7095           0 :                 if (PyLong_Check(value)) {
    7096           0 :                         unsigned long long test_var;
    7097           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7098           0 :                         if (PyErr_Occurred() != NULL) {
    7099           0 :                                 return -1;
    7100             :                         }
    7101           0 :                         if (test_var > uint_max) {
    7102           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7103             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7104           0 :                                 return -1;
    7105             :                         }
    7106           0 :                         object->dwRecursionTimeout = test_var;
    7107             :                 } else {
    7108           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7109             :                           PyLong_Type.tp_name);
    7110           0 :                         return -1;
    7111             :                 }
    7112             :         }
    7113           0 :         return 0;
    7114             : }
    7115             : 
    7116           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_dwMaxCacheTtl(PyObject *obj, void *closure)
    7117             : {
    7118           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7119           0 :         PyObject *py_dwMaxCacheTtl;
    7120           1 :         py_dwMaxCacheTtl = PyLong_FromUnsignedLongLong((uint32_t)(object->dwMaxCacheTtl));
    7121           1 :         return py_dwMaxCacheTtl;
    7122             : }
    7123             : 
    7124           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_dwMaxCacheTtl(PyObject *py_obj, PyObject *value, void *closure)
    7125             : {
    7126           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7127           0 :         if (value == NULL) {
    7128           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwMaxCacheTtl");
    7129           0 :                 return -1;
    7130             :         }
    7131             :         {
    7132           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwMaxCacheTtl));
    7133           0 :                 if (PyLong_Check(value)) {
    7134           0 :                         unsigned long long test_var;
    7135           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7136           0 :                         if (PyErr_Occurred() != NULL) {
    7137           0 :                                 return -1;
    7138             :                         }
    7139           0 :                         if (test_var > uint_max) {
    7140           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7141             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7142           0 :                                 return -1;
    7143             :                         }
    7144           0 :                         object->dwMaxCacheTtl = test_var;
    7145             :                 } else {
    7146           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7147             :                           PyLong_Type.tp_name);
    7148           0 :                         return -1;
    7149             :                 }
    7150             :         }
    7151           0 :         return 0;
    7152             : }
    7153             : 
    7154           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_dwDsPollingInterval(PyObject *obj, void *closure)
    7155             : {
    7156           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7157           0 :         PyObject *py_dwDsPollingInterval;
    7158           1 :         py_dwDsPollingInterval = PyLong_FromUnsignedLongLong((uint32_t)(object->dwDsPollingInterval));
    7159           1 :         return py_dwDsPollingInterval;
    7160             : }
    7161             : 
    7162           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_dwDsPollingInterval(PyObject *py_obj, PyObject *value, void *closure)
    7163             : {
    7164           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7165           0 :         if (value == NULL) {
    7166           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwDsPollingInterval");
    7167           0 :                 return -1;
    7168             :         }
    7169             :         {
    7170           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwDsPollingInterval));
    7171           0 :                 if (PyLong_Check(value)) {
    7172           0 :                         unsigned long long test_var;
    7173           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7174           0 :                         if (PyErr_Occurred() != NULL) {
    7175           0 :                                 return -1;
    7176             :                         }
    7177           0 :                         if (test_var > uint_max) {
    7178           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7179             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7180           0 :                                 return -1;
    7181             :                         }
    7182           0 :                         object->dwDsPollingInterval = test_var;
    7183             :                 } else {
    7184           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7185             :                           PyLong_Type.tp_name);
    7186           0 :                         return -1;
    7187             :                 }
    7188             :         }
    7189           0 :         return 0;
    7190             : }
    7191             : 
    7192           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_dwLocalNetPriorityNetMask(PyObject *obj, void *closure)
    7193             : {
    7194           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7195           0 :         PyObject *py_dwLocalNetPriorityNetMask;
    7196           1 :         py_dwLocalNetPriorityNetMask = PyLong_FromUnsignedLongLong((uint32_t)(object->dwLocalNetPriorityNetMask));
    7197           1 :         return py_dwLocalNetPriorityNetMask;
    7198             : }
    7199             : 
    7200           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_dwLocalNetPriorityNetMask(PyObject *py_obj, PyObject *value, void *closure)
    7201             : {
    7202           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7203           0 :         if (value == NULL) {
    7204           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwLocalNetPriorityNetMask");
    7205           0 :                 return -1;
    7206             :         }
    7207             :         {
    7208           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwLocalNetPriorityNetMask));
    7209           0 :                 if (PyLong_Check(value)) {
    7210           0 :                         unsigned long long test_var;
    7211           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7212           0 :                         if (PyErr_Occurred() != NULL) {
    7213           0 :                                 return -1;
    7214             :                         }
    7215           0 :                         if (test_var > uint_max) {
    7216           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7217             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7218           0 :                                 return -1;
    7219             :                         }
    7220           0 :                         object->dwLocalNetPriorityNetMask = test_var;
    7221             :                 } else {
    7222           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7223             :                           PyLong_Type.tp_name);
    7224           0 :                         return -1;
    7225             :                 }
    7226             :         }
    7227           0 :         return 0;
    7228             : }
    7229             : 
    7230           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_dwScavengingInterval(PyObject *obj, void *closure)
    7231             : {
    7232           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7233           0 :         PyObject *py_dwScavengingInterval;
    7234           1 :         py_dwScavengingInterval = PyLong_FromUnsignedLongLong((uint32_t)(object->dwScavengingInterval));
    7235           1 :         return py_dwScavengingInterval;
    7236             : }
    7237             : 
    7238           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_dwScavengingInterval(PyObject *py_obj, PyObject *value, void *closure)
    7239             : {
    7240           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7241           0 :         if (value == NULL) {
    7242           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwScavengingInterval");
    7243           0 :                 return -1;
    7244             :         }
    7245             :         {
    7246           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwScavengingInterval));
    7247           0 :                 if (PyLong_Check(value)) {
    7248           0 :                         unsigned long long test_var;
    7249           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7250           0 :                         if (PyErr_Occurred() != NULL) {
    7251           0 :                                 return -1;
    7252             :                         }
    7253           0 :                         if (test_var > uint_max) {
    7254           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7255             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7256           0 :                                 return -1;
    7257             :                         }
    7258           0 :                         object->dwScavengingInterval = test_var;
    7259             :                 } else {
    7260           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7261             :                           PyLong_Type.tp_name);
    7262           0 :                         return -1;
    7263             :                 }
    7264             :         }
    7265           0 :         return 0;
    7266             : }
    7267             : 
    7268           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_dwDefaultRefreshInterval(PyObject *obj, void *closure)
    7269             : {
    7270           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7271           0 :         PyObject *py_dwDefaultRefreshInterval;
    7272           1 :         py_dwDefaultRefreshInterval = PyLong_FromUnsignedLongLong((uint32_t)(object->dwDefaultRefreshInterval));
    7273           1 :         return py_dwDefaultRefreshInterval;
    7274             : }
    7275             : 
    7276           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_dwDefaultRefreshInterval(PyObject *py_obj, PyObject *value, void *closure)
    7277             : {
    7278           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7279           0 :         if (value == NULL) {
    7280           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwDefaultRefreshInterval");
    7281           0 :                 return -1;
    7282             :         }
    7283             :         {
    7284           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwDefaultRefreshInterval));
    7285           0 :                 if (PyLong_Check(value)) {
    7286           0 :                         unsigned long long test_var;
    7287           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7288           0 :                         if (PyErr_Occurred() != NULL) {
    7289           0 :                                 return -1;
    7290             :                         }
    7291           0 :                         if (test_var > uint_max) {
    7292           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7293             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7294           0 :                                 return -1;
    7295             :                         }
    7296           0 :                         object->dwDefaultRefreshInterval = test_var;
    7297             :                 } else {
    7298           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7299             :                           PyLong_Type.tp_name);
    7300           0 :                         return -1;
    7301             :                 }
    7302             :         }
    7303           0 :         return 0;
    7304             : }
    7305             : 
    7306           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_dwDefaultNoRefreshInterval(PyObject *obj, void *closure)
    7307             : {
    7308           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7309           0 :         PyObject *py_dwDefaultNoRefreshInterval;
    7310           1 :         py_dwDefaultNoRefreshInterval = PyLong_FromUnsignedLongLong((uint32_t)(object->dwDefaultNoRefreshInterval));
    7311           1 :         return py_dwDefaultNoRefreshInterval;
    7312             : }
    7313             : 
    7314           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_dwDefaultNoRefreshInterval(PyObject *py_obj, PyObject *value, void *closure)
    7315             : {
    7316           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7317           0 :         if (value == NULL) {
    7318           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwDefaultNoRefreshInterval");
    7319           0 :                 return -1;
    7320             :         }
    7321             :         {
    7322           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwDefaultNoRefreshInterval));
    7323           0 :                 if (PyLong_Check(value)) {
    7324           0 :                         unsigned long long test_var;
    7325           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7326           0 :                         if (PyErr_Occurred() != NULL) {
    7327           0 :                                 return -1;
    7328             :                         }
    7329           0 :                         if (test_var > uint_max) {
    7330           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7331             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7332           0 :                                 return -1;
    7333             :                         }
    7334           0 :                         object->dwDefaultNoRefreshInterval = test_var;
    7335             :                 } else {
    7336           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7337             :                           PyLong_Type.tp_name);
    7338           0 :                         return -1;
    7339             :                 }
    7340             :         }
    7341           0 :         return 0;
    7342             : }
    7343             : 
    7344           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_dwLastScavengeTime(PyObject *obj, void *closure)
    7345             : {
    7346           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7347           0 :         PyObject *py_dwLastScavengeTime;
    7348           1 :         py_dwLastScavengeTime = PyLong_FromUnsignedLongLong((uint32_t)(object->dwLastScavengeTime));
    7349           1 :         return py_dwLastScavengeTime;
    7350             : }
    7351             : 
    7352           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_dwLastScavengeTime(PyObject *py_obj, PyObject *value, void *closure)
    7353             : {
    7354           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7355           0 :         if (value == NULL) {
    7356           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwLastScavengeTime");
    7357           0 :                 return -1;
    7358             :         }
    7359             :         {
    7360           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwLastScavengeTime));
    7361           0 :                 if (PyLong_Check(value)) {
    7362           0 :                         unsigned long long test_var;
    7363           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7364           0 :                         if (PyErr_Occurred() != NULL) {
    7365           0 :                                 return -1;
    7366             :                         }
    7367           0 :                         if (test_var > uint_max) {
    7368           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7369             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7370           0 :                                 return -1;
    7371             :                         }
    7372           0 :                         object->dwLastScavengeTime = test_var;
    7373             :                 } else {
    7374           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7375             :                           PyLong_Type.tp_name);
    7376           0 :                         return -1;
    7377             :                 }
    7378             :         }
    7379           0 :         return 0;
    7380             : }
    7381             : 
    7382           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_dwEventLogLevel(PyObject *obj, void *closure)
    7383             : {
    7384           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7385           0 :         PyObject *py_dwEventLogLevel;
    7386           1 :         py_dwEventLogLevel = PyLong_FromUnsignedLongLong((uint32_t)(object->dwEventLogLevel));
    7387           1 :         return py_dwEventLogLevel;
    7388             : }
    7389             : 
    7390           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_dwEventLogLevel(PyObject *py_obj, PyObject *value, void *closure)
    7391             : {
    7392           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7393           0 :         if (value == NULL) {
    7394           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwEventLogLevel");
    7395           0 :                 return -1;
    7396             :         }
    7397             :         {
    7398           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwEventLogLevel));
    7399           0 :                 if (PyLong_Check(value)) {
    7400           0 :                         unsigned long long test_var;
    7401           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7402           0 :                         if (PyErr_Occurred() != NULL) {
    7403           0 :                                 return -1;
    7404             :                         }
    7405           0 :                         if (test_var > uint_max) {
    7406           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7407             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7408           0 :                                 return -1;
    7409             :                         }
    7410           0 :                         object->dwEventLogLevel = test_var;
    7411             :                 } else {
    7412           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7413             :                           PyLong_Type.tp_name);
    7414           0 :                         return -1;
    7415             :                 }
    7416             :         }
    7417           0 :         return 0;
    7418             : }
    7419             : 
    7420           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_dwLogFileMaxSize(PyObject *obj, void *closure)
    7421             : {
    7422           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7423           0 :         PyObject *py_dwLogFileMaxSize;
    7424           1 :         py_dwLogFileMaxSize = PyLong_FromUnsignedLongLong((uint32_t)(object->dwLogFileMaxSize));
    7425           1 :         return py_dwLogFileMaxSize;
    7426             : }
    7427             : 
    7428           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_dwLogFileMaxSize(PyObject *py_obj, PyObject *value, void *closure)
    7429             : {
    7430           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7431           0 :         if (value == NULL) {
    7432           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwLogFileMaxSize");
    7433           0 :                 return -1;
    7434             :         }
    7435             :         {
    7436           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwLogFileMaxSize));
    7437           0 :                 if (PyLong_Check(value)) {
    7438           0 :                         unsigned long long test_var;
    7439           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7440           0 :                         if (PyErr_Occurred() != NULL) {
    7441           0 :                                 return -1;
    7442             :                         }
    7443           0 :                         if (test_var > uint_max) {
    7444           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7445             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7446           0 :                                 return -1;
    7447             :                         }
    7448           0 :                         object->dwLogFileMaxSize = test_var;
    7449             :                 } else {
    7450           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7451             :                           PyLong_Type.tp_name);
    7452           0 :                         return -1;
    7453             :                 }
    7454             :         }
    7455           0 :         return 0;
    7456             : }
    7457             : 
    7458           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_dwDsForestVersion(PyObject *obj, void *closure)
    7459             : {
    7460           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7461           0 :         PyObject *py_dwDsForestVersion;
    7462           1 :         py_dwDsForestVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwDsForestVersion));
    7463           1 :         return py_dwDsForestVersion;
    7464             : }
    7465             : 
    7466           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_dwDsForestVersion(PyObject *py_obj, PyObject *value, void *closure)
    7467             : {
    7468           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7469           0 :         if (value == NULL) {
    7470           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwDsForestVersion");
    7471           0 :                 return -1;
    7472             :         }
    7473             :         {
    7474           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwDsForestVersion));
    7475           0 :                 if (PyLong_Check(value)) {
    7476           0 :                         unsigned long long test_var;
    7477           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7478           0 :                         if (PyErr_Occurred() != NULL) {
    7479           0 :                                 return -1;
    7480             :                         }
    7481           0 :                         if (test_var > uint_max) {
    7482           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7483             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7484           0 :                                 return -1;
    7485             :                         }
    7486           0 :                         object->dwDsForestVersion = test_var;
    7487             :                 } else {
    7488           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7489             :                           PyLong_Type.tp_name);
    7490           0 :                         return -1;
    7491             :                 }
    7492             :         }
    7493           0 :         return 0;
    7494             : }
    7495             : 
    7496           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_dwDsDomainVersion(PyObject *obj, void *closure)
    7497             : {
    7498           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7499           0 :         PyObject *py_dwDsDomainVersion;
    7500           1 :         py_dwDsDomainVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwDsDomainVersion));
    7501           1 :         return py_dwDsDomainVersion;
    7502             : }
    7503             : 
    7504           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_dwDsDomainVersion(PyObject *py_obj, PyObject *value, void *closure)
    7505             : {
    7506           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7507           0 :         if (value == NULL) {
    7508           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwDsDomainVersion");
    7509           0 :                 return -1;
    7510             :         }
    7511             :         {
    7512           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwDsDomainVersion));
    7513           0 :                 if (PyLong_Check(value)) {
    7514           0 :                         unsigned long long test_var;
    7515           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7516           0 :                         if (PyErr_Occurred() != NULL) {
    7517           0 :                                 return -1;
    7518             :                         }
    7519           0 :                         if (test_var > uint_max) {
    7520           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7521             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7522           0 :                                 return -1;
    7523             :                         }
    7524           0 :                         object->dwDsDomainVersion = test_var;
    7525             :                 } else {
    7526           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7527             :                           PyLong_Type.tp_name);
    7528           0 :                         return -1;
    7529             :                 }
    7530             :         }
    7531           0 :         return 0;
    7532             : }
    7533             : 
    7534           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_dwDsDsaVersion(PyObject *obj, void *closure)
    7535             : {
    7536           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7537           0 :         PyObject *py_dwDsDsaVersion;
    7538           1 :         py_dwDsDsaVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwDsDsaVersion));
    7539           1 :         return py_dwDsDsaVersion;
    7540             : }
    7541             : 
    7542           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_dwDsDsaVersion(PyObject *py_obj, PyObject *value, void *closure)
    7543             : {
    7544           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7545           0 :         if (value == NULL) {
    7546           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwDsDsaVersion");
    7547           0 :                 return -1;
    7548             :         }
    7549             :         {
    7550           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwDsDsaVersion));
    7551           0 :                 if (PyLong_Check(value)) {
    7552           0 :                         unsigned long long test_var;
    7553           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7554           0 :                         if (PyErr_Occurred() != NULL) {
    7555           0 :                                 return -1;
    7556             :                         }
    7557           0 :                         if (test_var > uint_max) {
    7558           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7559             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7560           0 :                                 return -1;
    7561             :                         }
    7562           0 :                         object->dwDsDsaVersion = test_var;
    7563             :                 } else {
    7564           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7565             :                           PyLong_Type.tp_name);
    7566           0 :                         return -1;
    7567             :                 }
    7568             :         }
    7569           0 :         return 0;
    7570             : }
    7571             : 
    7572           0 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_dwReserveArray(PyObject *obj, void *closure)
    7573             : {
    7574           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7575           0 :         PyObject *py_dwReserveArray;
    7576           0 :         py_dwReserveArray = PyList_New(4);
    7577           0 :         if (py_dwReserveArray == NULL) {
    7578           0 :                 return NULL;
    7579             :         }
    7580             :         {
    7581             :                 int dwReserveArray_cntr_0;
    7582           0 :                 for (dwReserveArray_cntr_0 = 0; dwReserveArray_cntr_0 < (4); dwReserveArray_cntr_0++) {
    7583           0 :                         PyObject *py_dwReserveArray_0;
    7584           0 :                         py_dwReserveArray_0 = PyLong_FromUnsignedLongLong((uint32_t)((object->dwReserveArray)[dwReserveArray_cntr_0]));
    7585           0 :                         PyList_SetItem(py_dwReserveArray, dwReserveArray_cntr_0, py_dwReserveArray_0);
    7586             :                 }
    7587             :         }
    7588           0 :         return py_dwReserveArray;
    7589             : }
    7590             : 
    7591           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_dwReserveArray(PyObject *py_obj, PyObject *value, void *closure)
    7592             : {
    7593           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7594           0 :         if (value == NULL) {
    7595           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserveArray");
    7596           0 :                 return -1;
    7597             :         }
    7598           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
    7599             :         {
    7600           0 :                 int dwReserveArray_cntr_0;
    7601           0 :                 if (ARRAY_SIZE(object->dwReserveArray) != PyList_GET_SIZE(value)) {
    7602           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));
    7603           0 :                         return -1;
    7604             :                 }
    7605           0 :                 for (dwReserveArray_cntr_0 = 0; dwReserveArray_cntr_0 < PyList_GET_SIZE(value); dwReserveArray_cntr_0++) {
    7606           0 :                         if (PyList_GET_ITEM(value, dwReserveArray_cntr_0) == NULL) {
    7607           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->dwReserveArray)[dwReserveArray_cntr_0]");
    7608           0 :                                 return -1;
    7609             :                         }
    7610             :                         {
    7611           0 :                                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof((object->dwReserveArray)[dwReserveArray_cntr_0]));
    7612           0 :                                 if (PyLong_Check(PyList_GET_ITEM(value, dwReserveArray_cntr_0))) {
    7613           0 :                                         unsigned long long test_var;
    7614           0 :                                         test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, dwReserveArray_cntr_0));
    7615           0 :                                         if (PyErr_Occurred() != NULL) {
    7616           0 :                                                 return -1;
    7617             :                                         }
    7618           0 :                                         if (test_var > uint_max) {
    7619           0 :                                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7620             :                                                   PyLong_Type.tp_name, uint_max, test_var);
    7621           0 :                                                 return -1;
    7622             :                                         }
    7623           0 :                                         (object->dwReserveArray)[dwReserveArray_cntr_0] = test_var;
    7624             :                                 } else {
    7625           0 :                                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7626             :                                           PyLong_Type.tp_name);
    7627           0 :                                         return -1;
    7628             :                                 }
    7629             :                         }
    7630             :                 }
    7631             :         }
    7632           0 :         return 0;
    7633             : }
    7634             : 
    7635           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_fAutoReverseZones(PyObject *obj, void *closure)
    7636             : {
    7637           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7638           0 :         PyObject *py_fAutoReverseZones;
    7639           1 :         py_fAutoReverseZones = PyLong_FromLong((uint16_t)(object->fAutoReverseZones));
    7640           1 :         return py_fAutoReverseZones;
    7641             : }
    7642             : 
    7643           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_fAutoReverseZones(PyObject *py_obj, PyObject *value, void *closure)
    7644             : {
    7645           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7646           0 :         if (value == NULL) {
    7647           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAutoReverseZones");
    7648           0 :                 return -1;
    7649             :         }
    7650             :         {
    7651           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAutoReverseZones));
    7652           0 :                 if (PyLong_Check(value)) {
    7653           0 :                         unsigned long long test_var;
    7654           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7655           0 :                         if (PyErr_Occurred() != NULL) {
    7656           0 :                                 return -1;
    7657             :                         }
    7658           0 :                         if (test_var > uint_max) {
    7659           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7660             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7661           0 :                                 return -1;
    7662             :                         }
    7663           0 :                         object->fAutoReverseZones = test_var;
    7664             :                 } else {
    7665           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7666             :                           PyLong_Type.tp_name);
    7667           0 :                         return -1;
    7668             :                 }
    7669             :         }
    7670           0 :         return 0;
    7671             : }
    7672             : 
    7673           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_fAutoCacheUpdate(PyObject *obj, void *closure)
    7674             : {
    7675           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7676           0 :         PyObject *py_fAutoCacheUpdate;
    7677           1 :         py_fAutoCacheUpdate = PyLong_FromLong((uint16_t)(object->fAutoCacheUpdate));
    7678           1 :         return py_fAutoCacheUpdate;
    7679             : }
    7680             : 
    7681           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_fAutoCacheUpdate(PyObject *py_obj, PyObject *value, void *closure)
    7682             : {
    7683           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7684           0 :         if (value == NULL) {
    7685           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAutoCacheUpdate");
    7686           0 :                 return -1;
    7687             :         }
    7688             :         {
    7689           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAutoCacheUpdate));
    7690           0 :                 if (PyLong_Check(value)) {
    7691           0 :                         unsigned long long test_var;
    7692           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7693           0 :                         if (PyErr_Occurred() != NULL) {
    7694           0 :                                 return -1;
    7695             :                         }
    7696           0 :                         if (test_var > uint_max) {
    7697           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7698             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7699           0 :                                 return -1;
    7700             :                         }
    7701           0 :                         object->fAutoCacheUpdate = test_var;
    7702             :                 } else {
    7703           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7704             :                           PyLong_Type.tp_name);
    7705           0 :                         return -1;
    7706             :                 }
    7707             :         }
    7708           0 :         return 0;
    7709             : }
    7710             : 
    7711           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_fRecurseAfterForwarding(PyObject *obj, void *closure)
    7712             : {
    7713           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7714           0 :         PyObject *py_fRecurseAfterForwarding;
    7715           1 :         py_fRecurseAfterForwarding = PyLong_FromLong((uint16_t)(object->fRecurseAfterForwarding));
    7716           1 :         return py_fRecurseAfterForwarding;
    7717             : }
    7718             : 
    7719           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_fRecurseAfterForwarding(PyObject *py_obj, PyObject *value, void *closure)
    7720             : {
    7721           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7722           0 :         if (value == NULL) {
    7723           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fRecurseAfterForwarding");
    7724           0 :                 return -1;
    7725             :         }
    7726             :         {
    7727           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fRecurseAfterForwarding));
    7728           0 :                 if (PyLong_Check(value)) {
    7729           0 :                         unsigned long long test_var;
    7730           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7731           0 :                         if (PyErr_Occurred() != NULL) {
    7732           0 :                                 return -1;
    7733             :                         }
    7734           0 :                         if (test_var > uint_max) {
    7735           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7736             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7737           0 :                                 return -1;
    7738             :                         }
    7739           0 :                         object->fRecurseAfterForwarding = test_var;
    7740             :                 } else {
    7741           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7742             :                           PyLong_Type.tp_name);
    7743           0 :                         return -1;
    7744             :                 }
    7745             :         }
    7746           0 :         return 0;
    7747             : }
    7748             : 
    7749           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_fForwardDelegations(PyObject *obj, void *closure)
    7750             : {
    7751           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7752           0 :         PyObject *py_fForwardDelegations;
    7753           1 :         py_fForwardDelegations = PyLong_FromLong((uint16_t)(object->fForwardDelegations));
    7754           1 :         return py_fForwardDelegations;
    7755             : }
    7756             : 
    7757           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_fForwardDelegations(PyObject *py_obj, PyObject *value, void *closure)
    7758             : {
    7759           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7760           0 :         if (value == NULL) {
    7761           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fForwardDelegations");
    7762           0 :                 return -1;
    7763             :         }
    7764             :         {
    7765           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fForwardDelegations));
    7766           0 :                 if (PyLong_Check(value)) {
    7767           0 :                         unsigned long long test_var;
    7768           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7769           0 :                         if (PyErr_Occurred() != NULL) {
    7770           0 :                                 return -1;
    7771             :                         }
    7772           0 :                         if (test_var > uint_max) {
    7773           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7774             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7775           0 :                                 return -1;
    7776             :                         }
    7777           0 :                         object->fForwardDelegations = test_var;
    7778             :                 } else {
    7779           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7780             :                           PyLong_Type.tp_name);
    7781           0 :                         return -1;
    7782             :                 }
    7783             :         }
    7784           0 :         return 0;
    7785             : }
    7786             : 
    7787           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_fNoRecursion(PyObject *obj, void *closure)
    7788             : {
    7789           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7790           0 :         PyObject *py_fNoRecursion;
    7791           1 :         py_fNoRecursion = PyLong_FromLong((uint16_t)(object->fNoRecursion));
    7792           1 :         return py_fNoRecursion;
    7793             : }
    7794             : 
    7795           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_fNoRecursion(PyObject *py_obj, PyObject *value, void *closure)
    7796             : {
    7797           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7798           0 :         if (value == NULL) {
    7799           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fNoRecursion");
    7800           0 :                 return -1;
    7801             :         }
    7802             :         {
    7803           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fNoRecursion));
    7804           0 :                 if (PyLong_Check(value)) {
    7805           0 :                         unsigned long long test_var;
    7806           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7807           0 :                         if (PyErr_Occurred() != NULL) {
    7808           0 :                                 return -1;
    7809             :                         }
    7810           0 :                         if (test_var > uint_max) {
    7811           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7812             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7813           0 :                                 return -1;
    7814             :                         }
    7815           0 :                         object->fNoRecursion = test_var;
    7816             :                 } else {
    7817           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7818             :                           PyLong_Type.tp_name);
    7819           0 :                         return -1;
    7820             :                 }
    7821             :         }
    7822           0 :         return 0;
    7823             : }
    7824             : 
    7825           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_fSecureResponses(PyObject *obj, void *closure)
    7826             : {
    7827           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7828           0 :         PyObject *py_fSecureResponses;
    7829           1 :         py_fSecureResponses = PyLong_FromLong((uint16_t)(object->fSecureResponses));
    7830           1 :         return py_fSecureResponses;
    7831             : }
    7832             : 
    7833           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_fSecureResponses(PyObject *py_obj, PyObject *value, void *closure)
    7834             : {
    7835           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7836           0 :         if (value == NULL) {
    7837           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fSecureResponses");
    7838           0 :                 return -1;
    7839             :         }
    7840             :         {
    7841           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fSecureResponses));
    7842           0 :                 if (PyLong_Check(value)) {
    7843           0 :                         unsigned long long test_var;
    7844           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7845           0 :                         if (PyErr_Occurred() != NULL) {
    7846           0 :                                 return -1;
    7847             :                         }
    7848           0 :                         if (test_var > uint_max) {
    7849           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7850             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7851           0 :                                 return -1;
    7852             :                         }
    7853           0 :                         object->fSecureResponses = test_var;
    7854             :                 } else {
    7855           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7856             :                           PyLong_Type.tp_name);
    7857           0 :                         return -1;
    7858             :                 }
    7859             :         }
    7860           0 :         return 0;
    7861             : }
    7862             : 
    7863           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_fRoundRobin(PyObject *obj, void *closure)
    7864             : {
    7865           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7866           0 :         PyObject *py_fRoundRobin;
    7867           1 :         py_fRoundRobin = PyLong_FromLong((uint16_t)(object->fRoundRobin));
    7868           1 :         return py_fRoundRobin;
    7869             : }
    7870             : 
    7871           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_fRoundRobin(PyObject *py_obj, PyObject *value, void *closure)
    7872             : {
    7873           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7874           0 :         if (value == NULL) {
    7875           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fRoundRobin");
    7876           0 :                 return -1;
    7877             :         }
    7878             :         {
    7879           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fRoundRobin));
    7880           0 :                 if (PyLong_Check(value)) {
    7881           0 :                         unsigned long long test_var;
    7882           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7883           0 :                         if (PyErr_Occurred() != NULL) {
    7884           0 :                                 return -1;
    7885             :                         }
    7886           0 :                         if (test_var > uint_max) {
    7887           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7888             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7889           0 :                                 return -1;
    7890             :                         }
    7891           0 :                         object->fRoundRobin = test_var;
    7892             :                 } else {
    7893           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7894             :                           PyLong_Type.tp_name);
    7895           0 :                         return -1;
    7896             :                 }
    7897             :         }
    7898           0 :         return 0;
    7899             : }
    7900             : 
    7901           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_fLocalNetPriority(PyObject *obj, void *closure)
    7902             : {
    7903           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7904           0 :         PyObject *py_fLocalNetPriority;
    7905           1 :         py_fLocalNetPriority = PyLong_FromLong((uint16_t)(object->fLocalNetPriority));
    7906           1 :         return py_fLocalNetPriority;
    7907             : }
    7908             : 
    7909           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_fLocalNetPriority(PyObject *py_obj, PyObject *value, void *closure)
    7910             : {
    7911           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7912           0 :         if (value == NULL) {
    7913           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fLocalNetPriority");
    7914           0 :                 return -1;
    7915             :         }
    7916             :         {
    7917           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fLocalNetPriority));
    7918           0 :                 if (PyLong_Check(value)) {
    7919           0 :                         unsigned long long test_var;
    7920           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7921           0 :                         if (PyErr_Occurred() != NULL) {
    7922           0 :                                 return -1;
    7923             :                         }
    7924           0 :                         if (test_var > uint_max) {
    7925           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7926             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7927           0 :                                 return -1;
    7928             :                         }
    7929           0 :                         object->fLocalNetPriority = test_var;
    7930             :                 } else {
    7931           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7932             :                           PyLong_Type.tp_name);
    7933           0 :                         return -1;
    7934             :                 }
    7935             :         }
    7936           0 :         return 0;
    7937             : }
    7938             : 
    7939           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_fBindSecondaries(PyObject *obj, void *closure)
    7940             : {
    7941           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7942           0 :         PyObject *py_fBindSecondaries;
    7943           1 :         py_fBindSecondaries = PyLong_FromLong((uint16_t)(object->fBindSecondaries));
    7944           1 :         return py_fBindSecondaries;
    7945             : }
    7946             : 
    7947           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_fBindSecondaries(PyObject *py_obj, PyObject *value, void *closure)
    7948             : {
    7949           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7950           0 :         if (value == NULL) {
    7951           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fBindSecondaries");
    7952           0 :                 return -1;
    7953             :         }
    7954             :         {
    7955           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fBindSecondaries));
    7956           0 :                 if (PyLong_Check(value)) {
    7957           0 :                         unsigned long long test_var;
    7958           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7959           0 :                         if (PyErr_Occurred() != NULL) {
    7960           0 :                                 return -1;
    7961             :                         }
    7962           0 :                         if (test_var > uint_max) {
    7963           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    7964             :                                   PyLong_Type.tp_name, uint_max, test_var);
    7965           0 :                                 return -1;
    7966             :                         }
    7967           0 :                         object->fBindSecondaries = test_var;
    7968             :                 } else {
    7969           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    7970             :                           PyLong_Type.tp_name);
    7971           0 :                         return -1;
    7972             :                 }
    7973             :         }
    7974           0 :         return 0;
    7975             : }
    7976             : 
    7977           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_fWriteAuthorityNs(PyObject *obj, void *closure)
    7978             : {
    7979           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    7980           0 :         PyObject *py_fWriteAuthorityNs;
    7981           1 :         py_fWriteAuthorityNs = PyLong_FromLong((uint16_t)(object->fWriteAuthorityNs));
    7982           1 :         return py_fWriteAuthorityNs;
    7983             : }
    7984             : 
    7985           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_fWriteAuthorityNs(PyObject *py_obj, PyObject *value, void *closure)
    7986             : {
    7987           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    7988           0 :         if (value == NULL) {
    7989           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fWriteAuthorityNs");
    7990           0 :                 return -1;
    7991             :         }
    7992             :         {
    7993           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fWriteAuthorityNs));
    7994           0 :                 if (PyLong_Check(value)) {
    7995           0 :                         unsigned long long test_var;
    7996           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    7997           0 :                         if (PyErr_Occurred() != NULL) {
    7998           0 :                                 return -1;
    7999             :                         }
    8000           0 :                         if (test_var > uint_max) {
    8001           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    8002             :                                   PyLong_Type.tp_name, uint_max, test_var);
    8003           0 :                                 return -1;
    8004             :                         }
    8005           0 :                         object->fWriteAuthorityNs = test_var;
    8006             :                 } else {
    8007           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    8008             :                           PyLong_Type.tp_name);
    8009           0 :                         return -1;
    8010             :                 }
    8011             :         }
    8012           0 :         return 0;
    8013             : }
    8014             : 
    8015           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_fStrictFileParsing(PyObject *obj, void *closure)
    8016             : {
    8017           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    8018           0 :         PyObject *py_fStrictFileParsing;
    8019           1 :         py_fStrictFileParsing = PyLong_FromLong((uint16_t)(object->fStrictFileParsing));
    8020           1 :         return py_fStrictFileParsing;
    8021             : }
    8022             : 
    8023           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_fStrictFileParsing(PyObject *py_obj, PyObject *value, void *closure)
    8024             : {
    8025           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    8026           0 :         if (value == NULL) {
    8027           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fStrictFileParsing");
    8028           0 :                 return -1;
    8029             :         }
    8030             :         {
    8031           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fStrictFileParsing));
    8032           0 :                 if (PyLong_Check(value)) {
    8033           0 :                         unsigned long long test_var;
    8034           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    8035           0 :                         if (PyErr_Occurred() != NULL) {
    8036           0 :                                 return -1;
    8037             :                         }
    8038           0 :                         if (test_var > uint_max) {
    8039           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    8040             :                                   PyLong_Type.tp_name, uint_max, test_var);
    8041           0 :                                 return -1;
    8042             :                         }
    8043           0 :                         object->fStrictFileParsing = test_var;
    8044             :                 } else {
    8045           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    8046             :                           PyLong_Type.tp_name);
    8047           0 :                         return -1;
    8048             :                 }
    8049             :         }
    8050           0 :         return 0;
    8051             : }
    8052             : 
    8053           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_fLooseWildcarding(PyObject *obj, void *closure)
    8054             : {
    8055           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    8056           0 :         PyObject *py_fLooseWildcarding;
    8057           1 :         py_fLooseWildcarding = PyLong_FromLong((uint16_t)(object->fLooseWildcarding));
    8058           1 :         return py_fLooseWildcarding;
    8059             : }
    8060             : 
    8061           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_fLooseWildcarding(PyObject *py_obj, PyObject *value, void *closure)
    8062             : {
    8063           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    8064           0 :         if (value == NULL) {
    8065           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fLooseWildcarding");
    8066           0 :                 return -1;
    8067             :         }
    8068             :         {
    8069           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fLooseWildcarding));
    8070           0 :                 if (PyLong_Check(value)) {
    8071           0 :                         unsigned long long test_var;
    8072           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    8073           0 :                         if (PyErr_Occurred() != NULL) {
    8074           0 :                                 return -1;
    8075             :                         }
    8076           0 :                         if (test_var > uint_max) {
    8077           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    8078             :                                   PyLong_Type.tp_name, uint_max, test_var);
    8079           0 :                                 return -1;
    8080             :                         }
    8081           0 :                         object->fLooseWildcarding = test_var;
    8082             :                 } else {
    8083           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    8084             :                           PyLong_Type.tp_name);
    8085           0 :                         return -1;
    8086             :                 }
    8087             :         }
    8088           0 :         return 0;
    8089             : }
    8090             : 
    8091           1 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_fDefaultAgingState(PyObject *obj, void *closure)
    8092             : {
    8093           1 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    8094           0 :         PyObject *py_fDefaultAgingState;
    8095           1 :         py_fDefaultAgingState = PyLong_FromLong((uint16_t)(object->fDefaultAgingState));
    8096           1 :         return py_fDefaultAgingState;
    8097             : }
    8098             : 
    8099           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_fDefaultAgingState(PyObject *py_obj, PyObject *value, void *closure)
    8100             : {
    8101           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    8102           0 :         if (value == NULL) {
    8103           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fDefaultAgingState");
    8104           0 :                 return -1;
    8105             :         }
    8106             :         {
    8107           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fDefaultAgingState));
    8108           0 :                 if (PyLong_Check(value)) {
    8109           0 :                         unsigned long long test_var;
    8110           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    8111           0 :                         if (PyErr_Occurred() != NULL) {
    8112           0 :                                 return -1;
    8113             :                         }
    8114           0 :                         if (test_var > uint_max) {
    8115           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    8116             :                                   PyLong_Type.tp_name, uint_max, test_var);
    8117           0 :                                 return -1;
    8118             :                         }
    8119           0 :                         object->fDefaultAgingState = test_var;
    8120             :                 } else {
    8121           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    8122             :                           PyLong_Type.tp_name);
    8123           0 :                         return -1;
    8124             :                 }
    8125             :         }
    8126           0 :         return 0;
    8127             : }
    8128             : 
    8129           0 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_get_fReserveArray(PyObject *obj, void *closure)
    8130             : {
    8131           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(obj);
    8132           0 :         PyObject *py_fReserveArray;
    8133           0 :         py_fReserveArray = PyList_New(15);
    8134           0 :         if (py_fReserveArray == NULL) {
    8135           0 :                 return NULL;
    8136             :         }
    8137             :         {
    8138             :                 int fReserveArray_cntr_0;
    8139           0 :                 for (fReserveArray_cntr_0 = 0; fReserveArray_cntr_0 < (15); fReserveArray_cntr_0++) {
    8140           0 :                         PyObject *py_fReserveArray_0;
    8141           0 :                         py_fReserveArray_0 = PyLong_FromLong((uint16_t)((object->fReserveArray)[fReserveArray_cntr_0]));
    8142           0 :                         PyList_SetItem(py_fReserveArray, fReserveArray_cntr_0, py_fReserveArray_0);
    8143             :                 }
    8144             :         }
    8145           0 :         return py_fReserveArray;
    8146             : }
    8147             : 
    8148           0 : static int py_DNS_RPC_SERVER_INFO_DOTNET_set_fReserveArray(PyObject *py_obj, PyObject *value, void *closure)
    8149             : {
    8150           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    8151           0 :         if (value == NULL) {
    8152           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fReserveArray");
    8153           0 :                 return -1;
    8154             :         }
    8155           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
    8156             :         {
    8157           0 :                 int fReserveArray_cntr_0;
    8158           0 :                 if (ARRAY_SIZE(object->fReserveArray) != PyList_GET_SIZE(value)) {
    8159           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));
    8160           0 :                         return -1;
    8161             :                 }
    8162           0 :                 for (fReserveArray_cntr_0 = 0; fReserveArray_cntr_0 < PyList_GET_SIZE(value); fReserveArray_cntr_0++) {
    8163           0 :                         if (PyList_GET_ITEM(value, fReserveArray_cntr_0) == NULL) {
    8164           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->fReserveArray)[fReserveArray_cntr_0]");
    8165           0 :                                 return -1;
    8166             :                         }
    8167             :                         {
    8168           0 :                                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof((object->fReserveArray)[fReserveArray_cntr_0]));
    8169           0 :                                 if (PyLong_Check(PyList_GET_ITEM(value, fReserveArray_cntr_0))) {
    8170           0 :                                         unsigned long long test_var;
    8171           0 :                                         test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, fReserveArray_cntr_0));
    8172           0 :                                         if (PyErr_Occurred() != NULL) {
    8173           0 :                                                 return -1;
    8174             :                                         }
    8175           0 :                                         if (test_var > uint_max) {
    8176           0 :                                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    8177             :                                                   PyLong_Type.tp_name, uint_max, test_var);
    8178           0 :                                                 return -1;
    8179             :                                         }
    8180           0 :                                         (object->fReserveArray)[fReserveArray_cntr_0] = test_var;
    8181             :                                 } else {
    8182           0 :                                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    8183             :                                           PyLong_Type.tp_name);
    8184           0 :                                         return -1;
    8185             :                                 }
    8186             :                         }
    8187             :                 }
    8188             :         }
    8189           0 :         return 0;
    8190             : }
    8191             : 
    8192             : static PyGetSetDef py_DNS_RPC_SERVER_INFO_DOTNET_getsetters[] = {
    8193             :         {
    8194             :                 .name = discard_const_p(char, "dwRpcStructureVersion"),
    8195             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_dwRpcStructureVersion,
    8196             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_dwRpcStructureVersion,
    8197             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    8198             :         },
    8199             :         {
    8200             :                 .name = discard_const_p(char, "dwReserved0"),
    8201             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_dwReserved0,
    8202             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_dwReserved0,
    8203             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    8204             :         },
    8205             :         {
    8206             :                 .name = discard_const_p(char, "dwVersion"),
    8207             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_dwVersion,
    8208             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_dwVersion,
    8209             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    8210             :         },
    8211             :         {
    8212             :                 .name = discard_const_p(char, "fBootMethod"),
    8213             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_fBootMethod,
    8214             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_fBootMethod,
    8215             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_BOOT_METHOD")
    8216             :         },
    8217             :         {
    8218             :                 .name = discard_const_p(char, "fAdminConfigured"),
    8219             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_fAdminConfigured,
    8220             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_fAdminConfigured,
    8221             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    8222             :         },
    8223             :         {
    8224             :                 .name = discard_const_p(char, "fAllowUpdate"),
    8225             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_fAllowUpdate,
    8226             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_fAllowUpdate,
    8227             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    8228             :         },
    8229             :         {
    8230             :                 .name = discard_const_p(char, "fDsAvailable"),
    8231             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_fDsAvailable,
    8232             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_fDsAvailable,
    8233             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    8234             :         },
    8235             :         {
    8236             :                 .name = discard_const_p(char, "pszServerName"),
    8237             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_pszServerName,
    8238             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_pszServerName,
    8239             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    8240             :         },
    8241             :         {
    8242             :                 .name = discard_const_p(char, "pszDsContainer"),
    8243             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_pszDsContainer,
    8244             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_pszDsContainer,
    8245             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
    8246             :         },
    8247             :         {
    8248             :                 .name = discard_const_p(char, "aipServerAddrs"),
    8249             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_aipServerAddrs,
    8250             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_aipServerAddrs,
    8251             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
    8252             :         },
    8253             :         {
    8254             :                 .name = discard_const_p(char, "aipListenAddrs"),
    8255             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_aipListenAddrs,
    8256             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_aipListenAddrs,
    8257             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
    8258             :         },
    8259             :         {
    8260             :                 .name = discard_const_p(char, "aipForwarders"),
    8261             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_aipForwarders,
    8262             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_aipForwarders,
    8263             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
    8264             :         },
    8265             :         {
    8266             :                 .name = discard_const_p(char, "aipLogFilter"),
    8267             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_aipLogFilter,
    8268             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_aipLogFilter,
    8269             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
    8270             :         },
    8271             :         {
    8272             :                 .name = discard_const_p(char, "pwszLogFilePath"),
    8273             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_pwszLogFilePath,
    8274             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_pwszLogFilePath,
    8275             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
    8276             :         },
    8277             :         {
    8278             :                 .name = discard_const_p(char, "pszDomainName"),
    8279             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_pszDomainName,
    8280             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_pszDomainName,
    8281             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    8282             :         },
    8283             :         {
    8284             :                 .name = discard_const_p(char, "pszForestName"),
    8285             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_pszForestName,
    8286             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_pszForestName,
    8287             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    8288             :         },
    8289             :         {
    8290             :                 .name = discard_const_p(char, "pszDomainDirectoryPartition"),
    8291             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_pszDomainDirectoryPartition,
    8292             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_pszDomainDirectoryPartition,
    8293             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    8294             :         },
    8295             :         {
    8296             :                 .name = discard_const_p(char, "pszForestDirectoryPartition"),
    8297             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_pszForestDirectoryPartition,
    8298             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_pszForestDirectoryPartition,
    8299             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    8300             :         },
    8301             :         {
    8302             :                 .name = discard_const_p(char, "pExtensions"),
    8303             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_pExtensions,
    8304             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_pExtensions,
    8305             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_EXTENSION")
    8306             :         },
    8307             :         {
    8308             :                 .name = discard_const_p(char, "dwLogLevel"),
    8309             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_dwLogLevel,
    8310             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_dwLogLevel,
    8311             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    8312             :         },
    8313             :         {
    8314             :                 .name = discard_const_p(char, "dwDebugLevel"),
    8315             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_dwDebugLevel,
    8316             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_dwDebugLevel,
    8317             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    8318             :         },
    8319             :         {
    8320             :                 .name = discard_const_p(char, "dwForwardTimeout"),
    8321             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_dwForwardTimeout,
    8322             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_dwForwardTimeout,
    8323             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    8324             :         },
    8325             :         {
    8326             :                 .name = discard_const_p(char, "dwRpcProtocol"),
    8327             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_dwRpcProtocol,
    8328             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_dwRpcProtocol,
    8329             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    8330             :         },
    8331             :         {
    8332             :                 .name = discard_const_p(char, "dwNameCheckFlag"),
    8333             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_dwNameCheckFlag,
    8334             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_dwNameCheckFlag,
    8335             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_NAME_CHECK_FLAG")
    8336             :         },
    8337             :         {
    8338             :                 .name = discard_const_p(char, "cAddressAnswerLimit"),
    8339             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_cAddressAnswerLimit,
    8340             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_cAddressAnswerLimit,
    8341             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    8342             :         },
    8343             :         {
    8344             :                 .name = discard_const_p(char, "dwRecursionRetry"),
    8345             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_dwRecursionRetry,
    8346             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_dwRecursionRetry,
    8347             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    8348             :         },
    8349             :         {
    8350             :                 .name = discard_const_p(char, "dwRecursionTimeout"),
    8351             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_dwRecursionTimeout,
    8352             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_dwRecursionTimeout,
    8353             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    8354             :         },
    8355             :         {
    8356             :                 .name = discard_const_p(char, "dwMaxCacheTtl"),
    8357             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_dwMaxCacheTtl,
    8358             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_dwMaxCacheTtl,
    8359             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    8360             :         },
    8361             :         {
    8362             :                 .name = discard_const_p(char, "dwDsPollingInterval"),
    8363             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_dwDsPollingInterval,
    8364             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_dwDsPollingInterval,
    8365             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    8366             :         },
    8367             :         {
    8368             :                 .name = discard_const_p(char, "dwLocalNetPriorityNetMask"),
    8369             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_dwLocalNetPriorityNetMask,
    8370             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_dwLocalNetPriorityNetMask,
    8371             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    8372             :         },
    8373             :         {
    8374             :                 .name = discard_const_p(char, "dwScavengingInterval"),
    8375             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_dwScavengingInterval,
    8376             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_dwScavengingInterval,
    8377             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    8378             :         },
    8379             :         {
    8380             :                 .name = discard_const_p(char, "dwDefaultRefreshInterval"),
    8381             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_dwDefaultRefreshInterval,
    8382             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_dwDefaultRefreshInterval,
    8383             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    8384             :         },
    8385             :         {
    8386             :                 .name = discard_const_p(char, "dwDefaultNoRefreshInterval"),
    8387             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_dwDefaultNoRefreshInterval,
    8388             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_dwDefaultNoRefreshInterval,
    8389             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    8390             :         },
    8391             :         {
    8392             :                 .name = discard_const_p(char, "dwLastScavengeTime"),
    8393             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_dwLastScavengeTime,
    8394             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_dwLastScavengeTime,
    8395             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    8396             :         },
    8397             :         {
    8398             :                 .name = discard_const_p(char, "dwEventLogLevel"),
    8399             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_dwEventLogLevel,
    8400             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_dwEventLogLevel,
    8401             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    8402             :         },
    8403             :         {
    8404             :                 .name = discard_const_p(char, "dwLogFileMaxSize"),
    8405             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_dwLogFileMaxSize,
    8406             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_dwLogFileMaxSize,
    8407             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    8408             :         },
    8409             :         {
    8410             :                 .name = discard_const_p(char, "dwDsForestVersion"),
    8411             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_dwDsForestVersion,
    8412             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_dwDsForestVersion,
    8413             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    8414             :         },
    8415             :         {
    8416             :                 .name = discard_const_p(char, "dwDsDomainVersion"),
    8417             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_dwDsDomainVersion,
    8418             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_dwDsDomainVersion,
    8419             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    8420             :         },
    8421             :         {
    8422             :                 .name = discard_const_p(char, "dwDsDsaVersion"),
    8423             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_dwDsDsaVersion,
    8424             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_dwDsDsaVersion,
    8425             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    8426             :         },
    8427             :         {
    8428             :                 .name = discard_const_p(char, "dwReserveArray"),
    8429             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_dwReserveArray,
    8430             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_dwReserveArray,
    8431             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
    8432             :         },
    8433             :         {
    8434             :                 .name = discard_const_p(char, "fAutoReverseZones"),
    8435             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_fAutoReverseZones,
    8436             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_fAutoReverseZones,
    8437             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    8438             :         },
    8439             :         {
    8440             :                 .name = discard_const_p(char, "fAutoCacheUpdate"),
    8441             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_fAutoCacheUpdate,
    8442             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_fAutoCacheUpdate,
    8443             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    8444             :         },
    8445             :         {
    8446             :                 .name = discard_const_p(char, "fRecurseAfterForwarding"),
    8447             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_fRecurseAfterForwarding,
    8448             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_fRecurseAfterForwarding,
    8449             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    8450             :         },
    8451             :         {
    8452             :                 .name = discard_const_p(char, "fForwardDelegations"),
    8453             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_fForwardDelegations,
    8454             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_fForwardDelegations,
    8455             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    8456             :         },
    8457             :         {
    8458             :                 .name = discard_const_p(char, "fNoRecursion"),
    8459             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_fNoRecursion,
    8460             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_fNoRecursion,
    8461             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    8462             :         },
    8463             :         {
    8464             :                 .name = discard_const_p(char, "fSecureResponses"),
    8465             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_fSecureResponses,
    8466             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_fSecureResponses,
    8467             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    8468             :         },
    8469             :         {
    8470             :                 .name = discard_const_p(char, "fRoundRobin"),
    8471             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_fRoundRobin,
    8472             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_fRoundRobin,
    8473             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    8474             :         },
    8475             :         {
    8476             :                 .name = discard_const_p(char, "fLocalNetPriority"),
    8477             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_fLocalNetPriority,
    8478             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_fLocalNetPriority,
    8479             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    8480             :         },
    8481             :         {
    8482             :                 .name = discard_const_p(char, "fBindSecondaries"),
    8483             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_fBindSecondaries,
    8484             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_fBindSecondaries,
    8485             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    8486             :         },
    8487             :         {
    8488             :                 .name = discard_const_p(char, "fWriteAuthorityNs"),
    8489             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_fWriteAuthorityNs,
    8490             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_fWriteAuthorityNs,
    8491             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    8492             :         },
    8493             :         {
    8494             :                 .name = discard_const_p(char, "fStrictFileParsing"),
    8495             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_fStrictFileParsing,
    8496             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_fStrictFileParsing,
    8497             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    8498             :         },
    8499             :         {
    8500             :                 .name = discard_const_p(char, "fLooseWildcarding"),
    8501             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_fLooseWildcarding,
    8502             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_fLooseWildcarding,
    8503             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    8504             :         },
    8505             :         {
    8506             :                 .name = discard_const_p(char, "fDefaultAgingState"),
    8507             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_fDefaultAgingState,
    8508             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_fDefaultAgingState,
    8509             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    8510             :         },
    8511             :         {
    8512             :                 .name = discard_const_p(char, "fReserveArray"),
    8513             :                 .get = py_DNS_RPC_SERVER_INFO_DOTNET_get_fReserveArray,
    8514             :                 .set = py_DNS_RPC_SERVER_INFO_DOTNET_set_fReserveArray,
    8515             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
    8516             :         },
    8517             :         { .name = NULL }
    8518             : };
    8519             : 
    8520           0 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
    8521             : {
    8522           0 :         return pytalloc_new(struct DNS_RPC_SERVER_INFO_DOTNET, type);
    8523             : }
    8524             : 
    8525           0 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_ndr_pack(PyObject *py_obj,  PyObject *Py_UNUSED(ignored))
    8526             : {
    8527           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    8528           0 :         PyObject *ret = NULL;
    8529           0 :         DATA_BLOB blob;
    8530           0 :         enum ndr_err_code err;
    8531           0 :         TALLOC_CTX *tmp_ctx = talloc_new(pytalloc_get_mem_ctx(py_obj));
    8532           0 :         if (tmp_ctx == NULL) {
    8533           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
    8534           0 :                 return NULL;
    8535             :         }
    8536           0 :         err = ndr_push_struct_blob(&blob, tmp_ctx, object, (ndr_push_flags_fn_t)ndr_push_DNS_RPC_SERVER_INFO_DOTNET);
    8537           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    8538           0 :                 TALLOC_FREE(tmp_ctx);
    8539           0 :                 PyErr_SetNdrError(err);
    8540           0 :                 return NULL;
    8541             :         }
    8542             : 
    8543           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
    8544           0 :         TALLOC_FREE(tmp_ctx);
    8545           0 :         return ret;
    8546             : }
    8547             : 
    8548           0 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
    8549             : {
    8550           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    8551           0 :         DATA_BLOB blob = {.data = NULL, .length = 0};
    8552           0 :         Py_ssize_t blob_length = 0;
    8553           0 :         enum ndr_err_code err;
    8554           0 :         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
    8555           0 :         PyObject *allow_remaining_obj = NULL;
    8556           0 :         bool allow_remaining = false;
    8557             : 
    8558           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|O:__ndr_unpack__",
    8559             :                 discard_const_p(char *, kwnames),
    8560             :                 &blob.data, &blob_length,
    8561             :                 &allow_remaining_obj)) {
    8562           0 :                 return NULL;
    8563             :         }
    8564           0 :         blob.length = blob_length;
    8565             : 
    8566           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
    8567           0 :                 allow_remaining = true;
    8568             :         }
    8569             : 
    8570           0 :         if (allow_remaining) {
    8571           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);
    8572             :         } else {
    8573           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);
    8574             :         }
    8575           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
    8576           0 :                 PyErr_SetNdrError(err);
    8577           0 :                 return NULL;
    8578             :         }
    8579             : 
    8580           0 :         Py_RETURN_NONE;
    8581             : }
    8582             : 
    8583           0 : static PyObject *py_DNS_RPC_SERVER_INFO_DOTNET_ndr_print(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
    8584             : {
    8585           0 :         struct DNS_RPC_SERVER_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
    8586           0 :         PyObject *ret;
    8587           0 :         char *retstr;
    8588             : 
    8589           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);
    8590           0 :         ret = PyUnicode_FromString(retstr);
    8591           0 :         talloc_free(retstr);
    8592             : 
    8593           0 :         return ret;
    8594             : }
    8595             : 
    8596             : static PyMethodDef py_DNS_RPC_SERVER_INFO_DOTNET_methods[] = {
    8597             :         { "__ndr_pack__", (PyCFunction)py_DNS_RPC_SERVER_INFO_DOTNET_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
    8598             :         { "__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" },
    8599             :         { "__ndr_print__", (PyCFunction)py_DNS_RPC_SERVER_INFO_DOTNET_ndr_print, METH_NOARGS, "S.ndr_print(object) -> None\nNDR print" },
    8600             :         { NULL, NULL, 0, NULL }
    8601             : };
    8602             : 
    8603             : 
    8604             : static PyTypeObject DNS_RPC_SERVER_INFO_DOTNET_Type = {
    8605             :         PyVarObject_HEAD_INIT(NULL, 0)
    8606             :         .tp_name = "dnsserver.DNS_RPC_SERVER_INFO_DOTNET",
    8607             :         .tp_getset = py_DNS_RPC_SERVER_INFO_DOTNET_getsetters,
    8608             :         .tp_methods = py_DNS_RPC_SERVER_INFO_DOTNET_methods,
    8609             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
    8610             :         .tp_new = py_DNS_RPC_SERVER_INFO_DOTNET_new,
    8611             : };
    8612             : 
    8613             : 
    8614           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwRpcStructureVersion(PyObject *obj, void *closure)
    8615             : {
    8616           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    8617           0 :         PyObject *py_dwRpcStructureVersion;
    8618           1 :         py_dwRpcStructureVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcStructureVersion));
    8619           1 :         return py_dwRpcStructureVersion;
    8620             : }
    8621             : 
    8622           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwRpcStructureVersion(PyObject *py_obj, PyObject *value, void *closure)
    8623             : {
    8624           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    8625           0 :         if (value == NULL) {
    8626           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcStructureVersion");
    8627           0 :                 return -1;
    8628             :         }
    8629             :         {
    8630           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcStructureVersion));
    8631           0 :                 if (PyLong_Check(value)) {
    8632           0 :                         unsigned long long test_var;
    8633           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    8634           0 :                         if (PyErr_Occurred() != NULL) {
    8635           0 :                                 return -1;
    8636             :                         }
    8637           0 :                         if (test_var > uint_max) {
    8638           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    8639             :                                   PyLong_Type.tp_name, uint_max, test_var);
    8640           0 :                                 return -1;
    8641             :                         }
    8642           0 :                         object->dwRpcStructureVersion = test_var;
    8643             :                 } else {
    8644           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    8645             :                           PyLong_Type.tp_name);
    8646           0 :                         return -1;
    8647             :                 }
    8648             :         }
    8649           0 :         return 0;
    8650             : }
    8651             : 
    8652           0 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwReserved0(PyObject *obj, void *closure)
    8653             : {
    8654           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    8655           0 :         PyObject *py_dwReserved0;
    8656           0 :         py_dwReserved0 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved0));
    8657           0 :         return py_dwReserved0;
    8658             : }
    8659             : 
    8660           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwReserved0(PyObject *py_obj, PyObject *value, void *closure)
    8661             : {
    8662           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    8663           0 :         if (value == NULL) {
    8664           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved0");
    8665           0 :                 return -1;
    8666             :         }
    8667             :         {
    8668           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved0));
    8669           0 :                 if (PyLong_Check(value)) {
    8670           0 :                         unsigned long long test_var;
    8671           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    8672           0 :                         if (PyErr_Occurred() != NULL) {
    8673           0 :                                 return -1;
    8674             :                         }
    8675           0 :                         if (test_var > uint_max) {
    8676           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    8677             :                                   PyLong_Type.tp_name, uint_max, test_var);
    8678           0 :                                 return -1;
    8679             :                         }
    8680           0 :                         object->dwReserved0 = test_var;
    8681             :                 } else {
    8682           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    8683             :                           PyLong_Type.tp_name);
    8684           0 :                         return -1;
    8685             :                 }
    8686             :         }
    8687           0 :         return 0;
    8688             : }
    8689             : 
    8690           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwVersion(PyObject *obj, void *closure)
    8691             : {
    8692           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    8693           0 :         PyObject *py_dwVersion;
    8694           1 :         py_dwVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwVersion));
    8695           1 :         return py_dwVersion;
    8696             : }
    8697             : 
    8698           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwVersion(PyObject *py_obj, PyObject *value, void *closure)
    8699             : {
    8700           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    8701           0 :         if (value == NULL) {
    8702           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwVersion");
    8703           0 :                 return -1;
    8704             :         }
    8705             :         {
    8706           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwVersion));
    8707           0 :                 if (PyLong_Check(value)) {
    8708           0 :                         unsigned long long test_var;
    8709           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    8710           0 :                         if (PyErr_Occurred() != NULL) {
    8711           0 :                                 return -1;
    8712             :                         }
    8713           0 :                         if (test_var > uint_max) {
    8714           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    8715             :                                   PyLong_Type.tp_name, uint_max, test_var);
    8716           0 :                                 return -1;
    8717             :                         }
    8718           0 :                         object->dwVersion = test_var;
    8719             :                 } else {
    8720           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    8721             :                           PyLong_Type.tp_name);
    8722           0 :                         return -1;
    8723             :                 }
    8724             :         }
    8725           0 :         return 0;
    8726             : }
    8727             : 
    8728           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_fBootMethod(PyObject *obj, void *closure)
    8729             : {
    8730           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    8731           0 :         PyObject *py_fBootMethod;
    8732           1 :         py_fBootMethod = PyLong_FromLong((uint16_t)(object->fBootMethod));
    8733           1 :         return py_fBootMethod;
    8734             : }
    8735             : 
    8736           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_fBootMethod(PyObject *py_obj, PyObject *value, void *closure)
    8737             : {
    8738           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    8739           0 :         if (value == NULL) {
    8740           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fBootMethod");
    8741           0 :                 return -1;
    8742             :         }
    8743             :         {
    8744           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fBootMethod));
    8745           0 :                 if (PyLong_Check(value)) {
    8746           0 :                         unsigned long long test_var;
    8747           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    8748           0 :                         if (PyErr_Occurred() != NULL) {
    8749           0 :                                 return -1;
    8750             :                         }
    8751           0 :                         if (test_var > uint_max) {
    8752           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    8753             :                                   PyLong_Type.tp_name, uint_max, test_var);
    8754           0 :                                 return -1;
    8755             :                         }
    8756           0 :                         object->fBootMethod = test_var;
    8757             :                 } else {
    8758           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    8759             :                           PyLong_Type.tp_name);
    8760           0 :                         return -1;
    8761             :                 }
    8762             :         }
    8763           0 :         return 0;
    8764             : }
    8765             : 
    8766           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_fAdminConfigured(PyObject *obj, void *closure)
    8767             : {
    8768           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    8769           0 :         PyObject *py_fAdminConfigured;
    8770           1 :         py_fAdminConfigured = PyLong_FromLong((uint16_t)(object->fAdminConfigured));
    8771           1 :         return py_fAdminConfigured;
    8772             : }
    8773             : 
    8774           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_fAdminConfigured(PyObject *py_obj, PyObject *value, void *closure)
    8775             : {
    8776           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    8777           0 :         if (value == NULL) {
    8778           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAdminConfigured");
    8779           0 :                 return -1;
    8780             :         }
    8781             :         {
    8782           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAdminConfigured));
    8783           0 :                 if (PyLong_Check(value)) {
    8784           0 :                         unsigned long long test_var;
    8785           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    8786           0 :                         if (PyErr_Occurred() != NULL) {
    8787           0 :                                 return -1;
    8788             :                         }
    8789           0 :                         if (test_var > uint_max) {
    8790           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    8791             :                                   PyLong_Type.tp_name, uint_max, test_var);
    8792           0 :                                 return -1;
    8793             :                         }
    8794           0 :                         object->fAdminConfigured = test_var;
    8795             :                 } else {
    8796           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    8797             :                           PyLong_Type.tp_name);
    8798           0 :                         return -1;
    8799             :                 }
    8800             :         }
    8801           0 :         return 0;
    8802             : }
    8803             : 
    8804           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_fAllowUpdate(PyObject *obj, void *closure)
    8805             : {
    8806           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    8807           0 :         PyObject *py_fAllowUpdate;
    8808           1 :         py_fAllowUpdate = PyLong_FromLong((uint16_t)(object->fAllowUpdate));
    8809           1 :         return py_fAllowUpdate;
    8810             : }
    8811             : 
    8812           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_fAllowUpdate(PyObject *py_obj, PyObject *value, void *closure)
    8813             : {
    8814           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    8815           0 :         if (value == NULL) {
    8816           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAllowUpdate");
    8817           0 :                 return -1;
    8818             :         }
    8819             :         {
    8820           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAllowUpdate));
    8821           0 :                 if (PyLong_Check(value)) {
    8822           0 :                         unsigned long long test_var;
    8823           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    8824           0 :                         if (PyErr_Occurred() != NULL) {
    8825           0 :                                 return -1;
    8826             :                         }
    8827           0 :                         if (test_var > uint_max) {
    8828           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    8829             :                                   PyLong_Type.tp_name, uint_max, test_var);
    8830           0 :                                 return -1;
    8831             :                         }
    8832           0 :                         object->fAllowUpdate = test_var;
    8833             :                 } else {
    8834           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    8835             :                           PyLong_Type.tp_name);
    8836           0 :                         return -1;
    8837             :                 }
    8838             :         }
    8839           0 :         return 0;
    8840             : }
    8841             : 
    8842           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_fDsAvailable(PyObject *obj, void *closure)
    8843             : {
    8844           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    8845           0 :         PyObject *py_fDsAvailable;
    8846           1 :         py_fDsAvailable = PyLong_FromLong((uint16_t)(object->fDsAvailable));
    8847           1 :         return py_fDsAvailable;
    8848             : }
    8849             : 
    8850           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_fDsAvailable(PyObject *py_obj, PyObject *value, void *closure)
    8851             : {
    8852           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    8853           0 :         if (value == NULL) {
    8854           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fDsAvailable");
    8855           0 :                 return -1;
    8856             :         }
    8857             :         {
    8858           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fDsAvailable));
    8859           0 :                 if (PyLong_Check(value)) {
    8860           0 :                         unsigned long long test_var;
    8861           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    8862           0 :                         if (PyErr_Occurred() != NULL) {
    8863           0 :                                 return -1;
    8864             :                         }
    8865           0 :                         if (test_var > uint_max) {
    8866           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    8867             :                                   PyLong_Type.tp_name, uint_max, test_var);
    8868           0 :                                 return -1;
    8869             :                         }
    8870           0 :                         object->fDsAvailable = test_var;
    8871             :                 } else {
    8872           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    8873             :                           PyLong_Type.tp_name);
    8874           0 :                         return -1;
    8875             :                 }
    8876             :         }
    8877           0 :         return 0;
    8878             : }
    8879             : 
    8880           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_pszServerName(PyObject *obj, void *closure)
    8881             : {
    8882           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    8883           0 :         PyObject *py_pszServerName;
    8884           1 :         if (object->pszServerName == NULL) {
    8885           0 :                 Py_RETURN_NONE;
    8886             :         }
    8887           1 :         if (object->pszServerName == NULL) {
    8888           0 :                 py_pszServerName = Py_None;
    8889           0 :                 Py_INCREF(py_pszServerName);
    8890             :         } else {
    8891           1 :                 if (object->pszServerName == NULL) {
    8892           0 :                         py_pszServerName = Py_None;
    8893           0 :                         Py_INCREF(py_pszServerName);
    8894             :                 } else {
    8895           1 :                         py_pszServerName = PyUnicode_Decode(object->pszServerName, strlen(object->pszServerName), "utf-8", "ignore");
    8896             :                 }
    8897             :         }
    8898           1 :         return py_pszServerName;
    8899             : }
    8900             : 
    8901           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_pszServerName(PyObject *py_obj, PyObject *value, void *closure)
    8902             : {
    8903           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    8904           0 :         if (value == NULL) {
    8905           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszServerName");
    8906           0 :                 return -1;
    8907             :         }
    8908           0 :         if (value == Py_None) {
    8909           0 :                 object->pszServerName = NULL;
    8910             :         } else {
    8911           0 :                 object->pszServerName = NULL;
    8912             :                 {
    8913           0 :                         const char *test_str;
    8914           0 :                         const char *talloc_str;
    8915           0 :                         PyObject *unicode = NULL;
    8916           0 :                         if (PyUnicode_Check(value)) {
    8917           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    8918           0 :                                 if (unicode == NULL) {
    8919           0 :                                         return -1;
    8920             :                                 }
    8921           0 :                                 test_str = PyBytes_AS_STRING(unicode);
    8922           0 :                         } else if (PyBytes_Check(value)) {
    8923           0 :                                 test_str = PyBytes_AS_STRING(value);
    8924             :                         } else {
    8925           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    8926           0 :                                 return -1;
    8927             :                         }
    8928           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    8929           0 :                         if (unicode != NULL) {
    8930           0 :                                 Py_DECREF(unicode);
    8931             :                         }
    8932           0 :                         if (talloc_str == NULL) {
    8933           0 :                                 PyErr_NoMemory();
    8934           0 :                                 return -1;
    8935             :                         }
    8936           0 :                         object->pszServerName = talloc_str;
    8937             :                 }
    8938             :         }
    8939           0 :         return 0;
    8940             : }
    8941             : 
    8942           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_pszDsContainer(PyObject *obj, void *closure)
    8943             : {
    8944           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    8945           0 :         PyObject *py_pszDsContainer;
    8946           1 :         if (object->pszDsContainer == NULL) {
    8947           0 :                 Py_RETURN_NONE;
    8948             :         }
    8949           1 :         if (object->pszDsContainer == NULL) {
    8950           0 :                 py_pszDsContainer = Py_None;
    8951           0 :                 Py_INCREF(py_pszDsContainer);
    8952             :         } else {
    8953           1 :                 if (object->pszDsContainer == NULL) {
    8954           0 :                         py_pszDsContainer = Py_None;
    8955           0 :                         Py_INCREF(py_pszDsContainer);
    8956             :                 } else {
    8957           1 :                         py_pszDsContainer = PyUnicode_Decode(object->pszDsContainer, strlen(object->pszDsContainer), "utf-8", "ignore");
    8958             :                 }
    8959             :         }
    8960           1 :         return py_pszDsContainer;
    8961             : }
    8962             : 
    8963           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_pszDsContainer(PyObject *py_obj, PyObject *value, void *closure)
    8964             : {
    8965           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    8966           0 :         if (value == NULL) {
    8967           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszDsContainer");
    8968           0 :                 return -1;
    8969             :         }
    8970           0 :         if (value == Py_None) {
    8971           0 :                 object->pszDsContainer = NULL;
    8972             :         } else {
    8973           0 :                 object->pszDsContainer = NULL;
    8974             :                 {
    8975           0 :                         const char *test_str;
    8976           0 :                         const char *talloc_str;
    8977           0 :                         PyObject *unicode = NULL;
    8978           0 :                         if (PyUnicode_Check(value)) {
    8979           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    8980           0 :                                 if (unicode == NULL) {
    8981           0 :                                         return -1;
    8982             :                                 }
    8983           0 :                                 test_str = PyBytes_AS_STRING(unicode);
    8984           0 :                         } else if (PyBytes_Check(value)) {
    8985           0 :                                 test_str = PyBytes_AS_STRING(value);
    8986             :                         } else {
    8987           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    8988           0 :                                 return -1;
    8989             :                         }
    8990           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    8991           0 :                         if (unicode != NULL) {
    8992           0 :                                 Py_DECREF(unicode);
    8993             :                         }
    8994           0 :                         if (talloc_str == NULL) {
    8995           0 :                                 PyErr_NoMemory();
    8996           0 :                                 return -1;
    8997             :                         }
    8998           0 :                         object->pszDsContainer = talloc_str;
    8999             :                 }
    9000             :         }
    9001           0 :         return 0;
    9002             : }
    9003             : 
    9004           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_aipServerAddrs(PyObject *obj, void *closure)
    9005             : {
    9006           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    9007           0 :         PyObject *py_aipServerAddrs;
    9008           1 :         if (object->aipServerAddrs == NULL) {
    9009           0 :                 Py_RETURN_NONE;
    9010             :         }
    9011           1 :         if (object->aipServerAddrs == NULL) {
    9012           0 :                 py_aipServerAddrs = Py_None;
    9013           0 :                 Py_INCREF(py_aipServerAddrs);
    9014             :         } else {
    9015           1 :                 py_aipServerAddrs = pytalloc_reference_ex(&DNS_ADDR_ARRAY_Type, object->aipServerAddrs, object->aipServerAddrs);
    9016             :         }
    9017           1 :         return py_aipServerAddrs;
    9018             : }
    9019             : 
    9020           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_aipServerAddrs(PyObject *py_obj, PyObject *value, void *closure)
    9021             : {
    9022           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    9023           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipServerAddrs));
    9024           0 :         if (value == NULL) {
    9025           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipServerAddrs");
    9026           0 :                 return -1;
    9027             :         }
    9028           0 :         if (value == Py_None) {
    9029           0 :                 object->aipServerAddrs = NULL;
    9030             :         } else {
    9031           0 :                 object->aipServerAddrs = NULL;
    9032           0 :                 PY_CHECK_TYPE(&DNS_ADDR_ARRAY_Type, value, return -1;);
    9033           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    9034           0 :                         PyErr_NoMemory();
    9035           0 :                         return -1;
    9036             :                 }
    9037           0 :                 object->aipServerAddrs = (struct DNS_ADDR_ARRAY *)pytalloc_get_ptr(value);
    9038             :         }
    9039           0 :         return 0;
    9040             : }
    9041             : 
    9042           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_aipListenAddrs(PyObject *obj, void *closure)
    9043             : {
    9044           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    9045           0 :         PyObject *py_aipListenAddrs;
    9046           1 :         if (object->aipListenAddrs == NULL) {
    9047           0 :                 Py_RETURN_NONE;
    9048             :         }
    9049           1 :         if (object->aipListenAddrs == NULL) {
    9050           0 :                 py_aipListenAddrs = Py_None;
    9051           0 :                 Py_INCREF(py_aipListenAddrs);
    9052             :         } else {
    9053           1 :                 py_aipListenAddrs = pytalloc_reference_ex(&DNS_ADDR_ARRAY_Type, object->aipListenAddrs, object->aipListenAddrs);
    9054             :         }
    9055           1 :         return py_aipListenAddrs;
    9056             : }
    9057             : 
    9058           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_aipListenAddrs(PyObject *py_obj, PyObject *value, void *closure)
    9059             : {
    9060           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    9061           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipListenAddrs));
    9062           0 :         if (value == NULL) {
    9063           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipListenAddrs");
    9064           0 :                 return -1;
    9065             :         }
    9066           0 :         if (value == Py_None) {
    9067           0 :                 object->aipListenAddrs = NULL;
    9068             :         } else {
    9069           0 :                 object->aipListenAddrs = NULL;
    9070           0 :                 PY_CHECK_TYPE(&DNS_ADDR_ARRAY_Type, value, return -1;);
    9071           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    9072           0 :                         PyErr_NoMemory();
    9073           0 :                         return -1;
    9074             :                 }
    9075           0 :                 object->aipListenAddrs = (struct DNS_ADDR_ARRAY *)pytalloc_get_ptr(value);
    9076             :         }
    9077           0 :         return 0;
    9078             : }
    9079             : 
    9080           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_aipForwarders(PyObject *obj, void *closure)
    9081             : {
    9082           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    9083           0 :         PyObject *py_aipForwarders;
    9084           1 :         if (object->aipForwarders == NULL) {
    9085           1 :                 Py_RETURN_NONE;
    9086             :         }
    9087           0 :         if (object->aipForwarders == NULL) {
    9088           0 :                 py_aipForwarders = Py_None;
    9089           0 :                 Py_INCREF(py_aipForwarders);
    9090             :         } else {
    9091           0 :                 py_aipForwarders = pytalloc_reference_ex(&DNS_ADDR_ARRAY_Type, object->aipForwarders, object->aipForwarders);
    9092             :         }
    9093           0 :         return py_aipForwarders;
    9094             : }
    9095             : 
    9096           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_aipForwarders(PyObject *py_obj, PyObject *value, void *closure)
    9097             : {
    9098           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    9099           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipForwarders));
    9100           0 :         if (value == NULL) {
    9101           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipForwarders");
    9102           0 :                 return -1;
    9103             :         }
    9104           0 :         if (value == Py_None) {
    9105           0 :                 object->aipForwarders = NULL;
    9106             :         } else {
    9107           0 :                 object->aipForwarders = NULL;
    9108           0 :                 PY_CHECK_TYPE(&DNS_ADDR_ARRAY_Type, value, return -1;);
    9109           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    9110           0 :                         PyErr_NoMemory();
    9111           0 :                         return -1;
    9112             :                 }
    9113           0 :                 object->aipForwarders = (struct DNS_ADDR_ARRAY *)pytalloc_get_ptr(value);
    9114             :         }
    9115           0 :         return 0;
    9116             : }
    9117             : 
    9118           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_aipLogFilter(PyObject *obj, void *closure)
    9119             : {
    9120           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    9121           0 :         PyObject *py_aipLogFilter;
    9122           1 :         if (object->aipLogFilter == NULL) {
    9123           1 :                 Py_RETURN_NONE;
    9124             :         }
    9125           0 :         if (object->aipLogFilter == NULL) {
    9126           0 :                 py_aipLogFilter = Py_None;
    9127           0 :                 Py_INCREF(py_aipLogFilter);
    9128             :         } else {
    9129           0 :                 py_aipLogFilter = pytalloc_reference_ex(&DNS_ADDR_ARRAY_Type, object->aipLogFilter, object->aipLogFilter);
    9130             :         }
    9131           0 :         return py_aipLogFilter;
    9132             : }
    9133             : 
    9134           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_aipLogFilter(PyObject *py_obj, PyObject *value, void *closure)
    9135             : {
    9136           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    9137           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipLogFilter));
    9138           0 :         if (value == NULL) {
    9139           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipLogFilter");
    9140           0 :                 return -1;
    9141             :         }
    9142           0 :         if (value == Py_None) {
    9143           0 :                 object->aipLogFilter = NULL;
    9144             :         } else {
    9145           0 :                 object->aipLogFilter = NULL;
    9146           0 :                 PY_CHECK_TYPE(&DNS_ADDR_ARRAY_Type, value, return -1;);
    9147           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
    9148           0 :                         PyErr_NoMemory();
    9149           0 :                         return -1;
    9150             :                 }
    9151           0 :                 object->aipLogFilter = (struct DNS_ADDR_ARRAY *)pytalloc_get_ptr(value);
    9152             :         }
    9153           0 :         return 0;
    9154             : }
    9155             : 
    9156           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_pwszLogFilePath(PyObject *obj, void *closure)
    9157             : {
    9158           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    9159           0 :         PyObject *py_pwszLogFilePath;
    9160           1 :         if (object->pwszLogFilePath == NULL) {
    9161           1 :                 Py_RETURN_NONE;
    9162             :         }
    9163           0 :         if (object->pwszLogFilePath == NULL) {
    9164           0 :                 py_pwszLogFilePath = Py_None;
    9165           0 :                 Py_INCREF(py_pwszLogFilePath);
    9166             :         } else {
    9167           0 :                 if (object->pwszLogFilePath == NULL) {
    9168           0 :                         py_pwszLogFilePath = Py_None;
    9169           0 :                         Py_INCREF(py_pwszLogFilePath);
    9170             :                 } else {
    9171           0 :                         py_pwszLogFilePath = PyUnicode_Decode(object->pwszLogFilePath, strlen(object->pwszLogFilePath), "utf-8", "ignore");
    9172             :                 }
    9173             :         }
    9174           0 :         return py_pwszLogFilePath;
    9175             : }
    9176             : 
    9177           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_pwszLogFilePath(PyObject *py_obj, PyObject *value, void *closure)
    9178             : {
    9179           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    9180           0 :         if (value == NULL) {
    9181           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pwszLogFilePath");
    9182           0 :                 return -1;
    9183             :         }
    9184           0 :         if (value == Py_None) {
    9185           0 :                 object->pwszLogFilePath = NULL;
    9186             :         } else {
    9187           0 :                 object->pwszLogFilePath = NULL;
    9188             :                 {
    9189           0 :                         const char *test_str;
    9190           0 :                         const char *talloc_str;
    9191           0 :                         PyObject *unicode = NULL;
    9192           0 :                         if (PyUnicode_Check(value)) {
    9193           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    9194           0 :                                 if (unicode == NULL) {
    9195           0 :                                         return -1;
    9196             :                                 }
    9197           0 :                                 test_str = PyBytes_AS_STRING(unicode);
    9198           0 :                         } else if (PyBytes_Check(value)) {
    9199           0 :                                 test_str = PyBytes_AS_STRING(value);
    9200             :                         } else {
    9201           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    9202           0 :                                 return -1;
    9203             :                         }
    9204           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    9205           0 :                         if (unicode != NULL) {
    9206           0 :                                 Py_DECREF(unicode);
    9207             :                         }
    9208           0 :                         if (talloc_str == NULL) {
    9209           0 :                                 PyErr_NoMemory();
    9210           0 :                                 return -1;
    9211             :                         }
    9212           0 :                         object->pwszLogFilePath = talloc_str;
    9213             :                 }
    9214             :         }
    9215           0 :         return 0;
    9216             : }
    9217             : 
    9218           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_pszDomainName(PyObject *obj, void *closure)
    9219             : {
    9220           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    9221           0 :         PyObject *py_pszDomainName;
    9222           1 :         if (object->pszDomainName == NULL) {
    9223           0 :                 Py_RETURN_NONE;
    9224             :         }
    9225           1 :         if (object->pszDomainName == NULL) {
    9226           0 :                 py_pszDomainName = Py_None;
    9227           0 :                 Py_INCREF(py_pszDomainName);
    9228             :         } else {
    9229           1 :                 if (object->pszDomainName == NULL) {
    9230           0 :                         py_pszDomainName = Py_None;
    9231           0 :                         Py_INCREF(py_pszDomainName);
    9232             :                 } else {
    9233           1 :                         py_pszDomainName = PyUnicode_Decode(object->pszDomainName, strlen(object->pszDomainName), "utf-8", "ignore");
    9234             :                 }
    9235             :         }
    9236           1 :         return py_pszDomainName;
    9237             : }
    9238             : 
    9239           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_pszDomainName(PyObject *py_obj, PyObject *value, void *closure)
    9240             : {
    9241           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    9242           0 :         if (value == NULL) {
    9243           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszDomainName");
    9244           0 :                 return -1;
    9245             :         }
    9246           0 :         if (value == Py_None) {
    9247           0 :                 object->pszDomainName = NULL;
    9248             :         } else {
    9249           0 :                 object->pszDomainName = NULL;
    9250             :                 {
    9251           0 :                         const char *test_str;
    9252           0 :                         const char *talloc_str;
    9253           0 :                         PyObject *unicode = NULL;
    9254           0 :                         if (PyUnicode_Check(value)) {
    9255           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    9256           0 :                                 if (unicode == NULL) {
    9257           0 :                                         return -1;
    9258             :                                 }
    9259           0 :                                 test_str = PyBytes_AS_STRING(unicode);
    9260           0 :                         } else if (PyBytes_Check(value)) {
    9261           0 :                                 test_str = PyBytes_AS_STRING(value);
    9262             :                         } else {
    9263           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    9264           0 :                                 return -1;
    9265             :                         }
    9266           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    9267           0 :                         if (unicode != NULL) {
    9268           0 :                                 Py_DECREF(unicode);
    9269             :                         }
    9270           0 :                         if (talloc_str == NULL) {
    9271           0 :                                 PyErr_NoMemory();
    9272           0 :                                 return -1;
    9273             :                         }
    9274           0 :                         object->pszDomainName = talloc_str;
    9275             :                 }
    9276             :         }
    9277           0 :         return 0;
    9278             : }
    9279             : 
    9280           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_pszForestName(PyObject *obj, void *closure)
    9281             : {
    9282           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    9283           0 :         PyObject *py_pszForestName;
    9284           1 :         if (object->pszForestName == NULL) {
    9285           0 :                 Py_RETURN_NONE;
    9286             :         }
    9287           1 :         if (object->pszForestName == NULL) {
    9288           0 :                 py_pszForestName = Py_None;
    9289           0 :                 Py_INCREF(py_pszForestName);
    9290             :         } else {
    9291           1 :                 if (object->pszForestName == NULL) {
    9292           0 :                         py_pszForestName = Py_None;
    9293           0 :                         Py_INCREF(py_pszForestName);
    9294             :                 } else {
    9295           1 :                         py_pszForestName = PyUnicode_Decode(object->pszForestName, strlen(object->pszForestName), "utf-8", "ignore");
    9296             :                 }
    9297             :         }
    9298           1 :         return py_pszForestName;
    9299             : }
    9300             : 
    9301           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_pszForestName(PyObject *py_obj, PyObject *value, void *closure)
    9302             : {
    9303           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    9304           0 :         if (value == NULL) {
    9305           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszForestName");
    9306           0 :                 return -1;
    9307             :         }
    9308           0 :         if (value == Py_None) {
    9309           0 :                 object->pszForestName = NULL;
    9310             :         } else {
    9311           0 :                 object->pszForestName = NULL;
    9312             :                 {
    9313           0 :                         const char *test_str;
    9314           0 :                         const char *talloc_str;
    9315           0 :                         PyObject *unicode = NULL;
    9316           0 :                         if (PyUnicode_Check(value)) {
    9317           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    9318           0 :                                 if (unicode == NULL) {
    9319           0 :                                         return -1;
    9320             :                                 }
    9321           0 :                                 test_str = PyBytes_AS_STRING(unicode);
    9322           0 :                         } else if (PyBytes_Check(value)) {
    9323           0 :                                 test_str = PyBytes_AS_STRING(value);
    9324             :                         } else {
    9325           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    9326           0 :                                 return -1;
    9327             :                         }
    9328           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    9329           0 :                         if (unicode != NULL) {
    9330           0 :                                 Py_DECREF(unicode);
    9331             :                         }
    9332           0 :                         if (talloc_str == NULL) {
    9333           0 :                                 PyErr_NoMemory();
    9334           0 :                                 return -1;
    9335             :                         }
    9336           0 :                         object->pszForestName = talloc_str;
    9337             :                 }
    9338             :         }
    9339           0 :         return 0;
    9340             : }
    9341             : 
    9342           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_pszDomainDirectoryPartition(PyObject *obj, void *closure)
    9343             : {
    9344           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    9345           0 :         PyObject *py_pszDomainDirectoryPartition;
    9346           1 :         if (object->pszDomainDirectoryPartition == NULL) {
    9347           0 :                 Py_RETURN_NONE;
    9348             :         }
    9349           1 :         if (object->pszDomainDirectoryPartition == NULL) {
    9350           0 :                 py_pszDomainDirectoryPartition = Py_None;
    9351           0 :                 Py_INCREF(py_pszDomainDirectoryPartition);
    9352             :         } else {
    9353           1 :                 if (object->pszDomainDirectoryPartition == NULL) {
    9354           0 :                         py_pszDomainDirectoryPartition = Py_None;
    9355           0 :                         Py_INCREF(py_pszDomainDirectoryPartition);
    9356             :                 } else {
    9357           1 :                         py_pszDomainDirectoryPartition = PyUnicode_Decode(object->pszDomainDirectoryPartition, strlen(object->pszDomainDirectoryPartition), "utf-8", "ignore");
    9358             :                 }
    9359             :         }
    9360           1 :         return py_pszDomainDirectoryPartition;
    9361             : }
    9362             : 
    9363           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_pszDomainDirectoryPartition(PyObject *py_obj, PyObject *value, void *closure)
    9364             : {
    9365           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    9366           0 :         if (value == NULL) {
    9367           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszDomainDirectoryPartition");
    9368           0 :                 return -1;
    9369             :         }
    9370           0 :         if (value == Py_None) {
    9371           0 :                 object->pszDomainDirectoryPartition = NULL;
    9372             :         } else {
    9373           0 :                 object->pszDomainDirectoryPartition = NULL;
    9374             :                 {
    9375           0 :                         const char *test_str;
    9376           0 :                         const char *talloc_str;
    9377           0 :                         PyObject *unicode = NULL;
    9378           0 :                         if (PyUnicode_Check(value)) {
    9379           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    9380           0 :                                 if (unicode == NULL) {
    9381           0 :                                         return -1;
    9382             :                                 }
    9383           0 :                                 test_str = PyBytes_AS_STRING(unicode);
    9384           0 :                         } else if (PyBytes_Check(value)) {
    9385           0 :                                 test_str = PyBytes_AS_STRING(value);
    9386             :                         } else {
    9387           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    9388           0 :                                 return -1;
    9389             :                         }
    9390           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    9391           0 :                         if (unicode != NULL) {
    9392           0 :                                 Py_DECREF(unicode);
    9393             :                         }
    9394           0 :                         if (talloc_str == NULL) {
    9395           0 :                                 PyErr_NoMemory();
    9396           0 :                                 return -1;
    9397             :                         }
    9398           0 :                         object->pszDomainDirectoryPartition = talloc_str;
    9399             :                 }
    9400             :         }
    9401           0 :         return 0;
    9402             : }
    9403             : 
    9404           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_pszForestDirectoryPartition(PyObject *obj, void *closure)
    9405             : {
    9406           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    9407           0 :         PyObject *py_pszForestDirectoryPartition;
    9408           1 :         if (object->pszForestDirectoryPartition == NULL) {
    9409           0 :                 Py_RETURN_NONE;
    9410             :         }
    9411           1 :         if (object->pszForestDirectoryPartition == NULL) {
    9412           0 :                 py_pszForestDirectoryPartition = Py_None;
    9413           0 :                 Py_INCREF(py_pszForestDirectoryPartition);
    9414             :         } else {
    9415           1 :                 if (object->pszForestDirectoryPartition == NULL) {
    9416           0 :                         py_pszForestDirectoryPartition = Py_None;
    9417           0 :                         Py_INCREF(py_pszForestDirectoryPartition);
    9418             :                 } else {
    9419           1 :                         py_pszForestDirectoryPartition = PyUnicode_Decode(object->pszForestDirectoryPartition, strlen(object->pszForestDirectoryPartition), "utf-8", "ignore");
    9420             :                 }
    9421             :         }
    9422           1 :         return py_pszForestDirectoryPartition;
    9423             : }
    9424             : 
    9425           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_pszForestDirectoryPartition(PyObject *py_obj, PyObject *value, void *closure)
    9426             : {
    9427           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    9428           0 :         if (value == NULL) {
    9429           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszForestDirectoryPartition");
    9430           0 :                 return -1;
    9431             :         }
    9432           0 :         if (value == Py_None) {
    9433           0 :                 object->pszForestDirectoryPartition = NULL;
    9434             :         } else {
    9435           0 :                 object->pszForestDirectoryPartition = NULL;
    9436             :                 {
    9437           0 :                         const char *test_str;
    9438           0 :                         const char *talloc_str;
    9439           0 :                         PyObject *unicode = NULL;
    9440           0 :                         if (PyUnicode_Check(value)) {
    9441           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
    9442           0 :                                 if (unicode == NULL) {
    9443           0 :                                         return -1;
    9444             :                                 }
    9445           0 :                                 test_str = PyBytes_AS_STRING(unicode);
    9446           0 :                         } else if (PyBytes_Check(value)) {
    9447           0 :                                 test_str = PyBytes_AS_STRING(value);
    9448             :                         } else {
    9449           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
    9450           0 :                                 return -1;
    9451             :                         }
    9452           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
    9453           0 :                         if (unicode != NULL) {
    9454           0 :                                 Py_DECREF(unicode);
    9455             :                         }
    9456           0 :                         if (talloc_str == NULL) {
    9457           0 :                                 PyErr_NoMemory();
    9458           0 :                                 return -1;
    9459             :                         }
    9460           0 :                         object->pszForestDirectoryPartition = talloc_str;
    9461             :                 }
    9462             :         }
    9463           0 :         return 0;
    9464             : }
    9465             : 
    9466           0 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_pExtensions(PyObject *obj, void *closure)
    9467             : {
    9468           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    9469           0 :         PyObject *py_pExtensions;
    9470           0 :         py_pExtensions = PyList_New(6);
    9471           0 :         if (py_pExtensions == NULL) {
    9472           0 :                 return NULL;
    9473             :         }
    9474             :         {
    9475             :                 int pExtensions_cntr_0;
    9476           0 :                 for (pExtensions_cntr_0 = 0; pExtensions_cntr_0 < (6); pExtensions_cntr_0++) {
    9477           0 :                         PyObject *py_pExtensions_0;
    9478           0 :                         py_pExtensions_0 = pytalloc_reference_ex(&DNS_EXTENSION_Type, pytalloc_get_mem_ctx(obj), &(object->pExtensions)[pExtensions_cntr_0]);
    9479           0 :                         PyList_SetItem(py_pExtensions, pExtensions_cntr_0, py_pExtensions_0);
    9480             :                 }
    9481             :         }
    9482           0 :         return py_pExtensions;
    9483             : }
    9484             : 
    9485           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_pExtensions(PyObject *py_obj, PyObject *value, void *closure)
    9486             : {
    9487           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    9488           0 :         if (value == NULL) {
    9489           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pExtensions");
    9490           0 :                 return -1;
    9491             :         }
    9492           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
    9493             :         {
    9494           0 :                 int pExtensions_cntr_0;
    9495           0 :                 if (ARRAY_SIZE(object->pExtensions) != PyList_GET_SIZE(value)) {
    9496           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));
    9497           0 :                         return -1;
    9498             :                 }
    9499           0 :                 for (pExtensions_cntr_0 = 0; pExtensions_cntr_0 < PyList_GET_SIZE(value); pExtensions_cntr_0++) {
    9500           0 :                         if (PyList_GET_ITEM(value, pExtensions_cntr_0) == NULL) {
    9501           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->pExtensions)[pExtensions_cntr_0]");
    9502           0 :                                 return -1;
    9503             :                         }
    9504           0 :                         PY_CHECK_TYPE(&DNS_EXTENSION_Type, PyList_GET_ITEM(value, pExtensions_cntr_0), return -1;);
    9505           0 :                         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(PyList_GET_ITEM(value, pExtensions_cntr_0))) == NULL) {
    9506           0 :                                 PyErr_NoMemory();
    9507           0 :                                 return -1;
    9508             :                         }
    9509           0 :                         (object->pExtensions)[pExtensions_cntr_0] = *(struct DNS_EXTENSION *)pytalloc_get_ptr(PyList_GET_ITEM(value, pExtensions_cntr_0));
    9510             :                 }
    9511             :         }
    9512           0 :         return 0;
    9513             : }
    9514             : 
    9515           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwLogLevel(PyObject *obj, void *closure)
    9516             : {
    9517           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    9518           0 :         PyObject *py_dwLogLevel;
    9519           1 :         py_dwLogLevel = PyLong_FromUnsignedLongLong((uint32_t)(object->dwLogLevel));
    9520           1 :         return py_dwLogLevel;
    9521             : }
    9522             : 
    9523           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwLogLevel(PyObject *py_obj, PyObject *value, void *closure)
    9524             : {
    9525           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    9526           0 :         if (value == NULL) {
    9527           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwLogLevel");
    9528           0 :                 return -1;
    9529             :         }
    9530             :         {
    9531           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwLogLevel));
    9532           0 :                 if (PyLong_Check(value)) {
    9533           0 :                         unsigned long long test_var;
    9534           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    9535           0 :                         if (PyErr_Occurred() != NULL) {
    9536           0 :                                 return -1;
    9537             :                         }
    9538           0 :                         if (test_var > uint_max) {
    9539           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    9540             :                                   PyLong_Type.tp_name, uint_max, test_var);
    9541           0 :                                 return -1;
    9542             :                         }
    9543           0 :                         object->dwLogLevel = test_var;
    9544             :                 } else {
    9545           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    9546             :                           PyLong_Type.tp_name);
    9547           0 :                         return -1;
    9548             :                 }
    9549             :         }
    9550           0 :         return 0;
    9551             : }
    9552             : 
    9553           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwDebugLevel(PyObject *obj, void *closure)
    9554             : {
    9555           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    9556           0 :         PyObject *py_dwDebugLevel;
    9557           1 :         py_dwDebugLevel = PyLong_FromUnsignedLongLong((uint32_t)(object->dwDebugLevel));
    9558           1 :         return py_dwDebugLevel;
    9559             : }
    9560             : 
    9561           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwDebugLevel(PyObject *py_obj, PyObject *value, void *closure)
    9562             : {
    9563           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    9564           0 :         if (value == NULL) {
    9565           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwDebugLevel");
    9566           0 :                 return -1;
    9567             :         }
    9568             :         {
    9569           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwDebugLevel));
    9570           0 :                 if (PyLong_Check(value)) {
    9571           0 :                         unsigned long long test_var;
    9572           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    9573           0 :                         if (PyErr_Occurred() != NULL) {
    9574           0 :                                 return -1;
    9575             :                         }
    9576           0 :                         if (test_var > uint_max) {
    9577           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    9578             :                                   PyLong_Type.tp_name, uint_max, test_var);
    9579           0 :                                 return -1;
    9580             :                         }
    9581           0 :                         object->dwDebugLevel = test_var;
    9582             :                 } else {
    9583           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    9584             :                           PyLong_Type.tp_name);
    9585           0 :                         return -1;
    9586             :                 }
    9587             :         }
    9588           0 :         return 0;
    9589             : }
    9590             : 
    9591           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwForwardTimeout(PyObject *obj, void *closure)
    9592             : {
    9593           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    9594           0 :         PyObject *py_dwForwardTimeout;
    9595           1 :         py_dwForwardTimeout = PyLong_FromUnsignedLongLong((uint32_t)(object->dwForwardTimeout));
    9596           1 :         return py_dwForwardTimeout;
    9597             : }
    9598             : 
    9599           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwForwardTimeout(PyObject *py_obj, PyObject *value, void *closure)
    9600             : {
    9601           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    9602           0 :         if (value == NULL) {
    9603           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwForwardTimeout");
    9604           0 :                 return -1;
    9605             :         }
    9606             :         {
    9607           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwForwardTimeout));
    9608           0 :                 if (PyLong_Check(value)) {
    9609           0 :                         unsigned long long test_var;
    9610           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    9611           0 :                         if (PyErr_Occurred() != NULL) {
    9612           0 :                                 return -1;
    9613             :                         }
    9614           0 :                         if (test_var > uint_max) {
    9615           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    9616             :                                   PyLong_Type.tp_name, uint_max, test_var);
    9617           0 :                                 return -1;
    9618             :                         }
    9619           0 :                         object->dwForwardTimeout = test_var;
    9620             :                 } else {
    9621           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    9622             :                           PyLong_Type.tp_name);
    9623           0 :                         return -1;
    9624             :                 }
    9625             :         }
    9626           0 :         return 0;
    9627             : }
    9628             : 
    9629           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwRpcProtocol(PyObject *obj, void *closure)
    9630             : {
    9631           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    9632           0 :         PyObject *py_dwRpcProtocol;
    9633           1 :         py_dwRpcProtocol = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcProtocol));
    9634           1 :         return py_dwRpcProtocol;
    9635             : }
    9636             : 
    9637           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwRpcProtocol(PyObject *py_obj, PyObject *value, void *closure)
    9638             : {
    9639           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    9640           0 :         if (value == NULL) {
    9641           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcProtocol");
    9642           0 :                 return -1;
    9643             :         }
    9644             :         {
    9645           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcProtocol));
    9646           0 :                 if (PyLong_Check(value)) {
    9647           0 :                         unsigned long long test_var;
    9648           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    9649           0 :                         if (PyErr_Occurred() != NULL) {
    9650           0 :                                 return -1;
    9651             :                         }
    9652           0 :                         if (test_var > uint_max) {
    9653           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    9654             :                                   PyLong_Type.tp_name, uint_max, test_var);
    9655           0 :                                 return -1;
    9656             :                         }
    9657           0 :                         object->dwRpcProtocol = test_var;
    9658             :                 } else {
    9659           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    9660             :                           PyLong_Type.tp_name);
    9661           0 :                         return -1;
    9662             :                 }
    9663             :         }
    9664           0 :         return 0;
    9665             : }
    9666             : 
    9667           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwNameCheckFlag(PyObject *obj, void *closure)
    9668             : {
    9669           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    9670           0 :         PyObject *py_dwNameCheckFlag;
    9671           1 :         py_dwNameCheckFlag = PyLong_FromUnsignedLongLong((uint32_t)(object->dwNameCheckFlag));
    9672           1 :         return py_dwNameCheckFlag;
    9673             : }
    9674             : 
    9675           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwNameCheckFlag(PyObject *py_obj, PyObject *value, void *closure)
    9676             : {
    9677           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    9678           0 :         if (value == NULL) {
    9679           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwNameCheckFlag");
    9680           0 :                 return -1;
    9681             :         }
    9682             :         {
    9683           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwNameCheckFlag));
    9684           0 :                 if (PyLong_Check(value)) {
    9685           0 :                         unsigned long long test_var;
    9686           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    9687           0 :                         if (PyErr_Occurred() != NULL) {
    9688           0 :                                 return -1;
    9689             :                         }
    9690           0 :                         if (test_var > uint_max) {
    9691           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    9692             :                                   PyLong_Type.tp_name, uint_max, test_var);
    9693           0 :                                 return -1;
    9694             :                         }
    9695           0 :                         object->dwNameCheckFlag = test_var;
    9696             :                 } else {
    9697           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    9698             :                           PyLong_Type.tp_name);
    9699           0 :                         return -1;
    9700             :                 }
    9701             :         }
    9702           0 :         return 0;
    9703             : }
    9704             : 
    9705           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_cAddressAnswerLimit(PyObject *obj, void *closure)
    9706             : {
    9707           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    9708           0 :         PyObject *py_cAddressAnswerLimit;
    9709           1 :         py_cAddressAnswerLimit = PyLong_FromUnsignedLongLong((uint32_t)(object->cAddressAnswerLimit));
    9710           1 :         return py_cAddressAnswerLimit;
    9711             : }
    9712             : 
    9713           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_cAddressAnswerLimit(PyObject *py_obj, PyObject *value, void *closure)
    9714             : {
    9715           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    9716           0 :         if (value == NULL) {
    9717           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->cAddressAnswerLimit");
    9718           0 :                 return -1;
    9719             :         }
    9720             :         {
    9721           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->cAddressAnswerLimit));
    9722           0 :                 if (PyLong_Check(value)) {
    9723           0 :                         unsigned long long test_var;
    9724           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    9725           0 :                         if (PyErr_Occurred() != NULL) {
    9726           0 :                                 return -1;
    9727             :                         }
    9728           0 :                         if (test_var > uint_max) {
    9729           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    9730             :                                   PyLong_Type.tp_name, uint_max, test_var);
    9731           0 :                                 return -1;
    9732             :                         }
    9733           0 :                         object->cAddressAnswerLimit = test_var;
    9734             :                 } else {
    9735           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    9736             :                           PyLong_Type.tp_name);
    9737           0 :                         return -1;
    9738             :                 }
    9739             :         }
    9740           0 :         return 0;
    9741             : }
    9742             : 
    9743           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwRecursionRetry(PyObject *obj, void *closure)
    9744             : {
    9745           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    9746           0 :         PyObject *py_dwRecursionRetry;
    9747           1 :         py_dwRecursionRetry = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRecursionRetry));
    9748           1 :         return py_dwRecursionRetry;
    9749             : }
    9750             : 
    9751           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwRecursionRetry(PyObject *py_obj, PyObject *value, void *closure)
    9752             : {
    9753           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    9754           0 :         if (value == NULL) {
    9755           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRecursionRetry");
    9756           0 :                 return -1;
    9757             :         }
    9758             :         {
    9759           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRecursionRetry));
    9760           0 :                 if (PyLong_Check(value)) {
    9761           0 :                         unsigned long long test_var;
    9762           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    9763           0 :                         if (PyErr_Occurred() != NULL) {
    9764           0 :                                 return -1;
    9765             :                         }
    9766           0 :                         if (test_var > uint_max) {
    9767           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    9768             :                                   PyLong_Type.tp_name, uint_max, test_var);
    9769           0 :                                 return -1;
    9770             :                         }
    9771           0 :                         object->dwRecursionRetry = test_var;
    9772             :                 } else {
    9773           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    9774             :                           PyLong_Type.tp_name);
    9775           0 :                         return -1;
    9776             :                 }
    9777             :         }
    9778           0 :         return 0;
    9779             : }
    9780             : 
    9781           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwRecursionTimeout(PyObject *obj, void *closure)
    9782             : {
    9783           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    9784           0 :         PyObject *py_dwRecursionTimeout;
    9785           1 :         py_dwRecursionTimeout = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRecursionTimeout));
    9786           1 :         return py_dwRecursionTimeout;
    9787             : }
    9788             : 
    9789           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwRecursionTimeout(PyObject *py_obj, PyObject *value, void *closure)
    9790             : {
    9791           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    9792           0 :         if (value == NULL) {
    9793           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRecursionTimeout");
    9794           0 :                 return -1;
    9795             :         }
    9796             :         {
    9797           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRecursionTimeout));
    9798           0 :                 if (PyLong_Check(value)) {
    9799           0 :                         unsigned long long test_var;
    9800           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    9801           0 :                         if (PyErr_Occurred() != NULL) {
    9802           0 :                                 return -1;
    9803             :                         }
    9804           0 :                         if (test_var > uint_max) {
    9805           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    9806             :                                   PyLong_Type.tp_name, uint_max, test_var);
    9807           0 :                                 return -1;
    9808             :                         }
    9809           0 :                         object->dwRecursionTimeout = test_var;
    9810             :                 } else {
    9811           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    9812             :                           PyLong_Type.tp_name);
    9813           0 :                         return -1;
    9814             :                 }
    9815             :         }
    9816           0 :         return 0;
    9817             : }
    9818             : 
    9819           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwMaxCacheTtl(PyObject *obj, void *closure)
    9820             : {
    9821           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    9822           0 :         PyObject *py_dwMaxCacheTtl;
    9823           1 :         py_dwMaxCacheTtl = PyLong_FromUnsignedLongLong((uint32_t)(object->dwMaxCacheTtl));
    9824           1 :         return py_dwMaxCacheTtl;
    9825             : }
    9826             : 
    9827           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwMaxCacheTtl(PyObject *py_obj, PyObject *value, void *closure)
    9828             : {
    9829           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    9830           0 :         if (value == NULL) {
    9831           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwMaxCacheTtl");
    9832           0 :                 return -1;
    9833             :         }
    9834             :         {
    9835           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwMaxCacheTtl));
    9836           0 :                 if (PyLong_Check(value)) {
    9837           0 :                         unsigned long long test_var;
    9838           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    9839           0 :                         if (PyErr_Occurred() != NULL) {
    9840           0 :                                 return -1;
    9841             :                         }
    9842           0 :                         if (test_var > uint_max) {
    9843           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    9844             :                                   PyLong_Type.tp_name, uint_max, test_var);
    9845           0 :                                 return -1;
    9846             :                         }
    9847           0 :                         object->dwMaxCacheTtl = test_var;
    9848             :                 } else {
    9849           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    9850             :                           PyLong_Type.tp_name);
    9851           0 :                         return -1;
    9852             :                 }
    9853             :         }
    9854           0 :         return 0;
    9855             : }
    9856             : 
    9857           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwDsPollingInterval(PyObject *obj, void *closure)
    9858             : {
    9859           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    9860           0 :         PyObject *py_dwDsPollingInterval;
    9861           1 :         py_dwDsPollingInterval = PyLong_FromUnsignedLongLong((uint32_t)(object->dwDsPollingInterval));
    9862           1 :         return py_dwDsPollingInterval;
    9863             : }
    9864             : 
    9865           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwDsPollingInterval(PyObject *py_obj, PyObject *value, void *closure)
    9866             : {
    9867           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    9868           0 :         if (value == NULL) {
    9869           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwDsPollingInterval");
    9870           0 :                 return -1;
    9871             :         }
    9872             :         {
    9873           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwDsPollingInterval));
    9874           0 :                 if (PyLong_Check(value)) {
    9875           0 :                         unsigned long long test_var;
    9876           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    9877           0 :                         if (PyErr_Occurred() != NULL) {
    9878           0 :                                 return -1;
    9879             :                         }
    9880           0 :                         if (test_var > uint_max) {
    9881           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    9882             :                                   PyLong_Type.tp_name, uint_max, test_var);
    9883           0 :                                 return -1;
    9884             :                         }
    9885           0 :                         object->dwDsPollingInterval = test_var;
    9886             :                 } else {
    9887           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    9888             :                           PyLong_Type.tp_name);
    9889           0 :                         return -1;
    9890             :                 }
    9891             :         }
    9892           0 :         return 0;
    9893             : }
    9894             : 
    9895           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwLocalNetPriorityNetMask(PyObject *obj, void *closure)
    9896             : {
    9897           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    9898           0 :         PyObject *py_dwLocalNetPriorityNetMask;
    9899           1 :         py_dwLocalNetPriorityNetMask = PyLong_FromUnsignedLongLong((uint32_t)(object->dwLocalNetPriorityNetMask));
    9900           1 :         return py_dwLocalNetPriorityNetMask;
    9901             : }
    9902             : 
    9903           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwLocalNetPriorityNetMask(PyObject *py_obj, PyObject *value, void *closure)
    9904             : {
    9905           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    9906           0 :         if (value == NULL) {
    9907           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwLocalNetPriorityNetMask");
    9908           0 :                 return -1;
    9909             :         }
    9910             :         {
    9911           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwLocalNetPriorityNetMask));
    9912           0 :                 if (PyLong_Check(value)) {
    9913           0 :                         unsigned long long test_var;
    9914           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    9915           0 :                         if (PyErr_Occurred() != NULL) {
    9916           0 :                                 return -1;
    9917             :                         }
    9918           0 :                         if (test_var > uint_max) {
    9919           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    9920             :                                   PyLong_Type.tp_name, uint_max, test_var);
    9921           0 :                                 return -1;
    9922             :                         }
    9923           0 :                         object->dwLocalNetPriorityNetMask = test_var;
    9924             :                 } else {
    9925           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    9926             :                           PyLong_Type.tp_name);
    9927           0 :                         return -1;
    9928             :                 }
    9929             :         }
    9930           0 :         return 0;
    9931             : }
    9932             : 
    9933           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwScavengingInterval(PyObject *obj, void *closure)
    9934             : {
    9935           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    9936           0 :         PyObject *py_dwScavengingInterval;
    9937           1 :         py_dwScavengingInterval = PyLong_FromUnsignedLongLong((uint32_t)(object->dwScavengingInterval));
    9938           1 :         return py_dwScavengingInterval;
    9939             : }
    9940             : 
    9941           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwScavengingInterval(PyObject *py_obj, PyObject *value, void *closure)
    9942             : {
    9943           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    9944           0 :         if (value == NULL) {
    9945           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwScavengingInterval");
    9946           0 :                 return -1;
    9947             :         }
    9948             :         {
    9949           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwScavengingInterval));
    9950           0 :                 if (PyLong_Check(value)) {
    9951           0 :                         unsigned long long test_var;
    9952           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    9953           0 :                         if (PyErr_Occurred() != NULL) {
    9954           0 :                                 return -1;
    9955             :                         }
    9956           0 :                         if (test_var > uint_max) {
    9957           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    9958             :                                   PyLong_Type.tp_name, uint_max, test_var);
    9959           0 :                                 return -1;
    9960             :                         }
    9961           0 :                         object->dwScavengingInterval = test_var;
    9962             :                 } else {
    9963           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
    9964             :                           PyLong_Type.tp_name);
    9965           0 :                         return -1;
    9966             :                 }
    9967             :         }
    9968           0 :         return 0;
    9969             : }
    9970             : 
    9971           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwDefaultRefreshInterval(PyObject *obj, void *closure)
    9972             : {
    9973           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
    9974           0 :         PyObject *py_dwDefaultRefreshInterval;
    9975           1 :         py_dwDefaultRefreshInterval = PyLong_FromUnsignedLongLong((uint32_t)(object->dwDefaultRefreshInterval));
    9976           1 :         return py_dwDefaultRefreshInterval;
    9977             : }
    9978             : 
    9979           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwDefaultRefreshInterval(PyObject *py_obj, PyObject *value, void *closure)
    9980             : {
    9981           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
    9982           0 :         if (value == NULL) {
    9983           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwDefaultRefreshInterval");
    9984           0 :                 return -1;
    9985             :         }
    9986             :         {
    9987           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwDefaultRefreshInterval));
    9988           0 :                 if (PyLong_Check(value)) {
    9989           0 :                         unsigned long long test_var;
    9990           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
    9991           0 :                         if (PyErr_Occurred() != NULL) {
    9992           0 :                                 return -1;
    9993             :                         }
    9994           0 :                         if (test_var > uint_max) {
    9995           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
    9996             :                                   PyLong_Type.tp_name, uint_max, test_var);
    9997           0 :                                 return -1;
    9998             :                         }
    9999           0 :                         object->dwDefaultRefreshInterval = test_var;
   10000             :                 } else {
   10001           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   10002             :                           PyLong_Type.tp_name);
   10003           0 :                         return -1;
   10004             :                 }
   10005             :         }
   10006           0 :         return 0;
   10007             : }
   10008             : 
   10009           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwDefaultNoRefreshInterval(PyObject *obj, void *closure)
   10010             : {
   10011           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   10012           0 :         PyObject *py_dwDefaultNoRefreshInterval;
   10013           1 :         py_dwDefaultNoRefreshInterval = PyLong_FromUnsignedLongLong((uint32_t)(object->dwDefaultNoRefreshInterval));
   10014           1 :         return py_dwDefaultNoRefreshInterval;
   10015             : }
   10016             : 
   10017           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwDefaultNoRefreshInterval(PyObject *py_obj, PyObject *value, void *closure)
   10018             : {
   10019           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   10020           0 :         if (value == NULL) {
   10021           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwDefaultNoRefreshInterval");
   10022           0 :                 return -1;
   10023             :         }
   10024             :         {
   10025           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwDefaultNoRefreshInterval));
   10026           0 :                 if (PyLong_Check(value)) {
   10027           0 :                         unsigned long long test_var;
   10028           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   10029           0 :                         if (PyErr_Occurred() != NULL) {
   10030           0 :                                 return -1;
   10031             :                         }
   10032           0 :                         if (test_var > uint_max) {
   10033           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   10034             :                                   PyLong_Type.tp_name, uint_max, test_var);
   10035           0 :                                 return -1;
   10036             :                         }
   10037           0 :                         object->dwDefaultNoRefreshInterval = test_var;
   10038             :                 } else {
   10039           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   10040             :                           PyLong_Type.tp_name);
   10041           0 :                         return -1;
   10042             :                 }
   10043             :         }
   10044           0 :         return 0;
   10045             : }
   10046             : 
   10047           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwLastScavengeTime(PyObject *obj, void *closure)
   10048             : {
   10049           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   10050           0 :         PyObject *py_dwLastScavengeTime;
   10051           1 :         py_dwLastScavengeTime = PyLong_FromUnsignedLongLong((uint32_t)(object->dwLastScavengeTime));
   10052           1 :         return py_dwLastScavengeTime;
   10053             : }
   10054             : 
   10055           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwLastScavengeTime(PyObject *py_obj, PyObject *value, void *closure)
   10056             : {
   10057           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   10058           0 :         if (value == NULL) {
   10059           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwLastScavengeTime");
   10060           0 :                 return -1;
   10061             :         }
   10062             :         {
   10063           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwLastScavengeTime));
   10064           0 :                 if (PyLong_Check(value)) {
   10065           0 :                         unsigned long long test_var;
   10066           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   10067           0 :                         if (PyErr_Occurred() != NULL) {
   10068           0 :                                 return -1;
   10069             :                         }
   10070           0 :                         if (test_var > uint_max) {
   10071           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   10072             :                                   PyLong_Type.tp_name, uint_max, test_var);
   10073           0 :                                 return -1;
   10074             :                         }
   10075           0 :                         object->dwLastScavengeTime = test_var;
   10076             :                 } else {
   10077           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   10078             :                           PyLong_Type.tp_name);
   10079           0 :                         return -1;
   10080             :                 }
   10081             :         }
   10082           0 :         return 0;
   10083             : }
   10084             : 
   10085           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwEventLogLevel(PyObject *obj, void *closure)
   10086             : {
   10087           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   10088           0 :         PyObject *py_dwEventLogLevel;
   10089           1 :         py_dwEventLogLevel = PyLong_FromUnsignedLongLong((uint32_t)(object->dwEventLogLevel));
   10090           1 :         return py_dwEventLogLevel;
   10091             : }
   10092             : 
   10093           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwEventLogLevel(PyObject *py_obj, PyObject *value, void *closure)
   10094             : {
   10095           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   10096           0 :         if (value == NULL) {
   10097           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwEventLogLevel");
   10098           0 :                 return -1;
   10099             :         }
   10100             :         {
   10101           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwEventLogLevel));
   10102           0 :                 if (PyLong_Check(value)) {
   10103           0 :                         unsigned long long test_var;
   10104           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   10105           0 :                         if (PyErr_Occurred() != NULL) {
   10106           0 :                                 return -1;
   10107             :                         }
   10108           0 :                         if (test_var > uint_max) {
   10109           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   10110             :                                   PyLong_Type.tp_name, uint_max, test_var);
   10111           0 :                                 return -1;
   10112             :                         }
   10113           0 :                         object->dwEventLogLevel = test_var;
   10114             :                 } else {
   10115           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   10116             :                           PyLong_Type.tp_name);
   10117           0 :                         return -1;
   10118             :                 }
   10119             :         }
   10120           0 :         return 0;
   10121             : }
   10122             : 
   10123           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwLogFileMaxSize(PyObject *obj, void *closure)
   10124             : {
   10125           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   10126           0 :         PyObject *py_dwLogFileMaxSize;
   10127           1 :         py_dwLogFileMaxSize = PyLong_FromUnsignedLongLong((uint32_t)(object->dwLogFileMaxSize));
   10128           1 :         return py_dwLogFileMaxSize;
   10129             : }
   10130             : 
   10131           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwLogFileMaxSize(PyObject *py_obj, PyObject *value, void *closure)
   10132             : {
   10133           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   10134           0 :         if (value == NULL) {
   10135           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwLogFileMaxSize");
   10136           0 :                 return -1;
   10137             :         }
   10138             :         {
   10139           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwLogFileMaxSize));
   10140           0 :                 if (PyLong_Check(value)) {
   10141           0 :                         unsigned long long test_var;
   10142           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   10143           0 :                         if (PyErr_Occurred() != NULL) {
   10144           0 :                                 return -1;
   10145             :                         }
   10146           0 :                         if (test_var > uint_max) {
   10147           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   10148             :                                   PyLong_Type.tp_name, uint_max, test_var);
   10149           0 :                                 return -1;
   10150             :                         }
   10151           0 :                         object->dwLogFileMaxSize = test_var;
   10152             :                 } else {
   10153           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   10154             :                           PyLong_Type.tp_name);
   10155           0 :                         return -1;
   10156             :                 }
   10157             :         }
   10158           0 :         return 0;
   10159             : }
   10160             : 
   10161           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwDsForestVersion(PyObject *obj, void *closure)
   10162             : {
   10163           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   10164           0 :         PyObject *py_dwDsForestVersion;
   10165           1 :         py_dwDsForestVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwDsForestVersion));
   10166           1 :         return py_dwDsForestVersion;
   10167             : }
   10168             : 
   10169           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwDsForestVersion(PyObject *py_obj, PyObject *value, void *closure)
   10170             : {
   10171           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   10172           0 :         if (value == NULL) {
   10173           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwDsForestVersion");
   10174           0 :                 return -1;
   10175             :         }
   10176             :         {
   10177           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwDsForestVersion));
   10178           0 :                 if (PyLong_Check(value)) {
   10179           0 :                         unsigned long long test_var;
   10180           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   10181           0 :                         if (PyErr_Occurred() != NULL) {
   10182           0 :                                 return -1;
   10183             :                         }
   10184           0 :                         if (test_var > uint_max) {
   10185           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   10186             :                                   PyLong_Type.tp_name, uint_max, test_var);
   10187           0 :                                 return -1;
   10188             :                         }
   10189           0 :                         object->dwDsForestVersion = test_var;
   10190             :                 } else {
   10191           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   10192             :                           PyLong_Type.tp_name);
   10193           0 :                         return -1;
   10194             :                 }
   10195             :         }
   10196           0 :         return 0;
   10197             : }
   10198             : 
   10199           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwDsDomainVersion(PyObject *obj, void *closure)
   10200             : {
   10201           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   10202           0 :         PyObject *py_dwDsDomainVersion;
   10203           1 :         py_dwDsDomainVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwDsDomainVersion));
   10204           1 :         return py_dwDsDomainVersion;
   10205             : }
   10206             : 
   10207           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwDsDomainVersion(PyObject *py_obj, PyObject *value, void *closure)
   10208             : {
   10209           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   10210           0 :         if (value == NULL) {
   10211           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwDsDomainVersion");
   10212           0 :                 return -1;
   10213             :         }
   10214             :         {
   10215           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwDsDomainVersion));
   10216           0 :                 if (PyLong_Check(value)) {
   10217           0 :                         unsigned long long test_var;
   10218           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   10219           0 :                         if (PyErr_Occurred() != NULL) {
   10220           0 :                                 return -1;
   10221             :                         }
   10222           0 :                         if (test_var > uint_max) {
   10223           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   10224             :                                   PyLong_Type.tp_name, uint_max, test_var);
   10225           0 :                                 return -1;
   10226             :                         }
   10227           0 :                         object->dwDsDomainVersion = test_var;
   10228             :                 } else {
   10229           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   10230             :                           PyLong_Type.tp_name);
   10231           0 :                         return -1;
   10232             :                 }
   10233             :         }
   10234           0 :         return 0;
   10235             : }
   10236             : 
   10237           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwDsDsaVersion(PyObject *obj, void *closure)
   10238             : {
   10239           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   10240           0 :         PyObject *py_dwDsDsaVersion;
   10241           1 :         py_dwDsDsaVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwDsDsaVersion));
   10242           1 :         return py_dwDsDsaVersion;
   10243             : }
   10244             : 
   10245           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwDsDsaVersion(PyObject *py_obj, PyObject *value, void *closure)
   10246             : {
   10247           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   10248           0 :         if (value == NULL) {
   10249           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwDsDsaVersion");
   10250           0 :                 return -1;
   10251             :         }
   10252             :         {
   10253           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwDsDsaVersion));
   10254           0 :                 if (PyLong_Check(value)) {
   10255           0 :                         unsigned long long test_var;
   10256           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   10257           0 :                         if (PyErr_Occurred() != NULL) {
   10258           0 :                                 return -1;
   10259             :                         }
   10260           0 :                         if (test_var > uint_max) {
   10261           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   10262             :                                   PyLong_Type.tp_name, uint_max, test_var);
   10263           0 :                                 return -1;
   10264             :                         }
   10265           0 :                         object->dwDsDsaVersion = test_var;
   10266             :                 } else {
   10267           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   10268             :                           PyLong_Type.tp_name);
   10269           0 :                         return -1;
   10270             :                 }
   10271             :         }
   10272           0 :         return 0;
   10273             : }
   10274             : 
   10275           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_fReadOnlyDC(PyObject *obj, void *closure)
   10276             : {
   10277           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   10278           0 :         PyObject *py_fReadOnlyDC;
   10279           1 :         py_fReadOnlyDC = PyLong_FromLong((uint16_t)(object->fReadOnlyDC));
   10280           1 :         return py_fReadOnlyDC;
   10281             : }
   10282             : 
   10283           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_fReadOnlyDC(PyObject *py_obj, PyObject *value, void *closure)
   10284             : {
   10285           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   10286           0 :         if (value == NULL) {
   10287           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fReadOnlyDC");
   10288           0 :                 return -1;
   10289             :         }
   10290             :         {
   10291           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fReadOnlyDC));
   10292           0 :                 if (PyLong_Check(value)) {
   10293           0 :                         unsigned long long test_var;
   10294           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   10295           0 :                         if (PyErr_Occurred() != NULL) {
   10296           0 :                                 return -1;
   10297             :                         }
   10298           0 :                         if (test_var > uint_max) {
   10299           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   10300             :                                   PyLong_Type.tp_name, uint_max, test_var);
   10301           0 :                                 return -1;
   10302             :                         }
   10303           0 :                         object->fReadOnlyDC = test_var;
   10304             :                 } else {
   10305           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   10306             :                           PyLong_Type.tp_name);
   10307           0 :                         return -1;
   10308             :                 }
   10309             :         }
   10310           0 :         return 0;
   10311             : }
   10312             : 
   10313           0 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwReserveArray(PyObject *obj, void *closure)
   10314             : {
   10315           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   10316           0 :         PyObject *py_dwReserveArray;
   10317           0 :         py_dwReserveArray = PyList_New(3);
   10318           0 :         if (py_dwReserveArray == NULL) {
   10319           0 :                 return NULL;
   10320             :         }
   10321             :         {
   10322             :                 int dwReserveArray_cntr_0;
   10323           0 :                 for (dwReserveArray_cntr_0 = 0; dwReserveArray_cntr_0 < (3); dwReserveArray_cntr_0++) {
   10324           0 :                         PyObject *py_dwReserveArray_0;
   10325           0 :                         py_dwReserveArray_0 = PyLong_FromUnsignedLongLong((uint32_t)((object->dwReserveArray)[dwReserveArray_cntr_0]));
   10326           0 :                         PyList_SetItem(py_dwReserveArray, dwReserveArray_cntr_0, py_dwReserveArray_0);
   10327             :                 }
   10328             :         }
   10329           0 :         return py_dwReserveArray;
   10330             : }
   10331             : 
   10332           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwReserveArray(PyObject *py_obj, PyObject *value, void *closure)
   10333             : {
   10334           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   10335           0 :         if (value == NULL) {
   10336           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserveArray");
   10337           0 :                 return -1;
   10338             :         }
   10339           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
   10340             :         {
   10341           0 :                 int dwReserveArray_cntr_0;
   10342           0 :                 if (ARRAY_SIZE(object->dwReserveArray) != PyList_GET_SIZE(value)) {
   10343           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));
   10344           0 :                         return -1;
   10345             :                 }
   10346           0 :                 for (dwReserveArray_cntr_0 = 0; dwReserveArray_cntr_0 < PyList_GET_SIZE(value); dwReserveArray_cntr_0++) {
   10347           0 :                         if (PyList_GET_ITEM(value, dwReserveArray_cntr_0) == NULL) {
   10348           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->dwReserveArray)[dwReserveArray_cntr_0]");
   10349           0 :                                 return -1;
   10350             :                         }
   10351             :                         {
   10352           0 :                                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof((object->dwReserveArray)[dwReserveArray_cntr_0]));
   10353           0 :                                 if (PyLong_Check(PyList_GET_ITEM(value, dwReserveArray_cntr_0))) {
   10354           0 :                                         unsigned long long test_var;
   10355           0 :                                         test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, dwReserveArray_cntr_0));
   10356           0 :                                         if (PyErr_Occurred() != NULL) {
   10357           0 :                                                 return -1;
   10358             :                                         }
   10359           0 :                                         if (test_var > uint_max) {
   10360           0 :                                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   10361             :                                                   PyLong_Type.tp_name, uint_max, test_var);
   10362           0 :                                                 return -1;
   10363             :                                         }
   10364           0 :                                         (object->dwReserveArray)[dwReserveArray_cntr_0] = test_var;
   10365             :                                 } else {
   10366           0 :                                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   10367             :                                           PyLong_Type.tp_name);
   10368           0 :                                         return -1;
   10369             :                                 }
   10370             :                         }
   10371             :                 }
   10372             :         }
   10373           0 :         return 0;
   10374             : }
   10375             : 
   10376           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_fAutoReverseZones(PyObject *obj, void *closure)
   10377             : {
   10378           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   10379           0 :         PyObject *py_fAutoReverseZones;
   10380           1 :         py_fAutoReverseZones = PyLong_FromLong((uint16_t)(object->fAutoReverseZones));
   10381           1 :         return py_fAutoReverseZones;
   10382             : }
   10383             : 
   10384           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_fAutoReverseZones(PyObject *py_obj, PyObject *value, void *closure)
   10385             : {
   10386           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   10387           0 :         if (value == NULL) {
   10388           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAutoReverseZones");
   10389           0 :                 return -1;
   10390             :         }
   10391             :         {
   10392           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAutoReverseZones));
   10393           0 :                 if (PyLong_Check(value)) {
   10394           0 :                         unsigned long long test_var;
   10395           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   10396           0 :                         if (PyErr_Occurred() != NULL) {
   10397           0 :                                 return -1;
   10398             :                         }
   10399           0 :                         if (test_var > uint_max) {
   10400           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   10401             :                                   PyLong_Type.tp_name, uint_max, test_var);
   10402           0 :                                 return -1;
   10403             :                         }
   10404           0 :                         object->fAutoReverseZones = test_var;
   10405             :                 } else {
   10406           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   10407             :                           PyLong_Type.tp_name);
   10408           0 :                         return -1;
   10409             :                 }
   10410             :         }
   10411           0 :         return 0;
   10412             : }
   10413             : 
   10414           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_fAutoCacheUpdate(PyObject *obj, void *closure)
   10415             : {
   10416           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   10417           0 :         PyObject *py_fAutoCacheUpdate;
   10418           1 :         py_fAutoCacheUpdate = PyLong_FromLong((uint16_t)(object->fAutoCacheUpdate));
   10419           1 :         return py_fAutoCacheUpdate;
   10420             : }
   10421             : 
   10422           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_fAutoCacheUpdate(PyObject *py_obj, PyObject *value, void *closure)
   10423             : {
   10424           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   10425           0 :         if (value == NULL) {
   10426           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAutoCacheUpdate");
   10427           0 :                 return -1;
   10428             :         }
   10429             :         {
   10430           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAutoCacheUpdate));
   10431           0 :                 if (PyLong_Check(value)) {
   10432           0 :                         unsigned long long test_var;
   10433           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   10434           0 :                         if (PyErr_Occurred() != NULL) {
   10435           0 :                                 return -1;
   10436             :                         }
   10437           0 :                         if (test_var > uint_max) {
   10438           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   10439             :                                   PyLong_Type.tp_name, uint_max, test_var);
   10440           0 :                                 return -1;
   10441             :                         }
   10442           0 :                         object->fAutoCacheUpdate = test_var;
   10443             :                 } else {
   10444           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   10445             :                           PyLong_Type.tp_name);
   10446           0 :                         return -1;
   10447             :                 }
   10448             :         }
   10449           0 :         return 0;
   10450             : }
   10451             : 
   10452           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_fRecurseAfterForwarding(PyObject *obj, void *closure)
   10453             : {
   10454           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   10455           0 :         PyObject *py_fRecurseAfterForwarding;
   10456           1 :         py_fRecurseAfterForwarding = PyLong_FromLong((uint16_t)(object->fRecurseAfterForwarding));
   10457           1 :         return py_fRecurseAfterForwarding;
   10458             : }
   10459             : 
   10460           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_fRecurseAfterForwarding(PyObject *py_obj, PyObject *value, void *closure)
   10461             : {
   10462           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   10463           0 :         if (value == NULL) {
   10464           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fRecurseAfterForwarding");
   10465           0 :                 return -1;
   10466             :         }
   10467             :         {
   10468           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fRecurseAfterForwarding));
   10469           0 :                 if (PyLong_Check(value)) {
   10470           0 :                         unsigned long long test_var;
   10471           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   10472           0 :                         if (PyErr_Occurred() != NULL) {
   10473           0 :                                 return -1;
   10474             :                         }
   10475           0 :                         if (test_var > uint_max) {
   10476           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   10477             :                                   PyLong_Type.tp_name, uint_max, test_var);
   10478           0 :                                 return -1;
   10479             :                         }
   10480           0 :                         object->fRecurseAfterForwarding = test_var;
   10481             :                 } else {
   10482           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   10483             :                           PyLong_Type.tp_name);
   10484           0 :                         return -1;
   10485             :                 }
   10486             :         }
   10487           0 :         return 0;
   10488             : }
   10489             : 
   10490           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_fForwardDelegations(PyObject *obj, void *closure)
   10491             : {
   10492           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   10493           0 :         PyObject *py_fForwardDelegations;
   10494           1 :         py_fForwardDelegations = PyLong_FromLong((uint16_t)(object->fForwardDelegations));
   10495           1 :         return py_fForwardDelegations;
   10496             : }
   10497             : 
   10498           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_fForwardDelegations(PyObject *py_obj, PyObject *value, void *closure)
   10499             : {
   10500           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   10501           0 :         if (value == NULL) {
   10502           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fForwardDelegations");
   10503           0 :                 return -1;
   10504             :         }
   10505             :         {
   10506           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fForwardDelegations));
   10507           0 :                 if (PyLong_Check(value)) {
   10508           0 :                         unsigned long long test_var;
   10509           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   10510           0 :                         if (PyErr_Occurred() != NULL) {
   10511           0 :                                 return -1;
   10512             :                         }
   10513           0 :                         if (test_var > uint_max) {
   10514           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   10515             :                                   PyLong_Type.tp_name, uint_max, test_var);
   10516           0 :                                 return -1;
   10517             :                         }
   10518           0 :                         object->fForwardDelegations = test_var;
   10519             :                 } else {
   10520           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   10521             :                           PyLong_Type.tp_name);
   10522           0 :                         return -1;
   10523             :                 }
   10524             :         }
   10525           0 :         return 0;
   10526             : }
   10527             : 
   10528           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_fNoRecursion(PyObject *obj, void *closure)
   10529             : {
   10530           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   10531           0 :         PyObject *py_fNoRecursion;
   10532           1 :         py_fNoRecursion = PyLong_FromLong((uint16_t)(object->fNoRecursion));
   10533           1 :         return py_fNoRecursion;
   10534             : }
   10535             : 
   10536           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_fNoRecursion(PyObject *py_obj, PyObject *value, void *closure)
   10537             : {
   10538           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   10539           0 :         if (value == NULL) {
   10540           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fNoRecursion");
   10541           0 :                 return -1;
   10542             :         }
   10543             :         {
   10544           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fNoRecursion));
   10545           0 :                 if (PyLong_Check(value)) {
   10546           0 :                         unsigned long long test_var;
   10547           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   10548           0 :                         if (PyErr_Occurred() != NULL) {
   10549           0 :                                 return -1;
   10550             :                         }
   10551           0 :                         if (test_var > uint_max) {
   10552           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   10553             :                                   PyLong_Type.tp_name, uint_max, test_var);
   10554           0 :                                 return -1;
   10555             :                         }
   10556           0 :                         object->fNoRecursion = test_var;
   10557             :                 } else {
   10558           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   10559             :                           PyLong_Type.tp_name);
   10560           0 :                         return -1;
   10561             :                 }
   10562             :         }
   10563           0 :         return 0;
   10564             : }
   10565             : 
   10566           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_fSecureResponses(PyObject *obj, void *closure)
   10567             : {
   10568           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   10569           0 :         PyObject *py_fSecureResponses;
   10570           1 :         py_fSecureResponses = PyLong_FromLong((uint16_t)(object->fSecureResponses));
   10571           1 :         return py_fSecureResponses;
   10572             : }
   10573             : 
   10574           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_fSecureResponses(PyObject *py_obj, PyObject *value, void *closure)
   10575             : {
   10576           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   10577           0 :         if (value == NULL) {
   10578           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fSecureResponses");
   10579           0 :                 return -1;
   10580             :         }
   10581             :         {
   10582           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fSecureResponses));
   10583           0 :                 if (PyLong_Check(value)) {
   10584           0 :                         unsigned long long test_var;
   10585           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   10586           0 :                         if (PyErr_Occurred() != NULL) {
   10587           0 :                                 return -1;
   10588             :                         }
   10589           0 :                         if (test_var > uint_max) {
   10590           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   10591             :                                   PyLong_Type.tp_name, uint_max, test_var);
   10592           0 :                                 return -1;
   10593             :                         }
   10594           0 :                         object->fSecureResponses = test_var;
   10595             :                 } else {
   10596           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   10597             :                           PyLong_Type.tp_name);
   10598           0 :                         return -1;
   10599             :                 }
   10600             :         }
   10601           0 :         return 0;
   10602             : }
   10603             : 
   10604           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_fRoundRobin(PyObject *obj, void *closure)
   10605             : {
   10606           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   10607           0 :         PyObject *py_fRoundRobin;
   10608           1 :         py_fRoundRobin = PyLong_FromLong((uint16_t)(object->fRoundRobin));
   10609           1 :         return py_fRoundRobin;
   10610             : }
   10611             : 
   10612           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_fRoundRobin(PyObject *py_obj, PyObject *value, void *closure)
   10613             : {
   10614           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   10615           0 :         if (value == NULL) {
   10616           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fRoundRobin");
   10617           0 :                 return -1;
   10618             :         }
   10619             :         {
   10620           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fRoundRobin));
   10621           0 :                 if (PyLong_Check(value)) {
   10622           0 :                         unsigned long long test_var;
   10623           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   10624           0 :                         if (PyErr_Occurred() != NULL) {
   10625           0 :                                 return -1;
   10626             :                         }
   10627           0 :                         if (test_var > uint_max) {
   10628           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   10629             :                                   PyLong_Type.tp_name, uint_max, test_var);
   10630           0 :                                 return -1;
   10631             :                         }
   10632           0 :                         object->fRoundRobin = test_var;
   10633             :                 } else {
   10634           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   10635             :                           PyLong_Type.tp_name);
   10636           0 :                         return -1;
   10637             :                 }
   10638             :         }
   10639           0 :         return 0;
   10640             : }
   10641             : 
   10642           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_fLocalNetPriority(PyObject *obj, void *closure)
   10643             : {
   10644           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   10645           0 :         PyObject *py_fLocalNetPriority;
   10646           1 :         py_fLocalNetPriority = PyLong_FromLong((uint16_t)(object->fLocalNetPriority));
   10647           1 :         return py_fLocalNetPriority;
   10648             : }
   10649             : 
   10650           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_fLocalNetPriority(PyObject *py_obj, PyObject *value, void *closure)
   10651             : {
   10652           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   10653           0 :         if (value == NULL) {
   10654           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fLocalNetPriority");
   10655           0 :                 return -1;
   10656             :         }
   10657             :         {
   10658           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fLocalNetPriority));
   10659           0 :                 if (PyLong_Check(value)) {
   10660           0 :                         unsigned long long test_var;
   10661           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   10662           0 :                         if (PyErr_Occurred() != NULL) {
   10663           0 :                                 return -1;
   10664             :                         }
   10665           0 :                         if (test_var > uint_max) {
   10666           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   10667             :                                   PyLong_Type.tp_name, uint_max, test_var);
   10668           0 :                                 return -1;
   10669             :                         }
   10670           0 :                         object->fLocalNetPriority = test_var;
   10671             :                 } else {
   10672           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   10673             :                           PyLong_Type.tp_name);
   10674           0 :                         return -1;
   10675             :                 }
   10676             :         }
   10677           0 :         return 0;
   10678             : }
   10679             : 
   10680           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_fBindSecondaries(PyObject *obj, void *closure)
   10681             : {
   10682           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   10683           0 :         PyObject *py_fBindSecondaries;
   10684           1 :         py_fBindSecondaries = PyLong_FromLong((uint16_t)(object->fBindSecondaries));
   10685           1 :         return py_fBindSecondaries;
   10686             : }
   10687             : 
   10688           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_fBindSecondaries(PyObject *py_obj, PyObject *value, void *closure)
   10689             : {
   10690           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   10691           0 :         if (value == NULL) {
   10692           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fBindSecondaries");
   10693           0 :                 return -1;
   10694             :         }
   10695             :         {
   10696           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fBindSecondaries));
   10697           0 :                 if (PyLong_Check(value)) {
   10698           0 :                         unsigned long long test_var;
   10699           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   10700           0 :                         if (PyErr_Occurred() != NULL) {
   10701           0 :                                 return -1;
   10702             :                         }
   10703           0 :                         if (test_var > uint_max) {
   10704           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   10705             :                                   PyLong_Type.tp_name, uint_max, test_var);
   10706           0 :                                 return -1;
   10707             :                         }
   10708           0 :                         object->fBindSecondaries = test_var;
   10709             :                 } else {
   10710           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   10711             :                           PyLong_Type.tp_name);
   10712           0 :                         return -1;
   10713             :                 }
   10714             :         }
   10715           0 :         return 0;
   10716             : }
   10717             : 
   10718           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_fWriteAuthorityNs(PyObject *obj, void *closure)
   10719             : {
   10720           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   10721           0 :         PyObject *py_fWriteAuthorityNs;
   10722           1 :         py_fWriteAuthorityNs = PyLong_FromLong((uint16_t)(object->fWriteAuthorityNs));
   10723           1 :         return py_fWriteAuthorityNs;
   10724             : }
   10725             : 
   10726           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_fWriteAuthorityNs(PyObject *py_obj, PyObject *value, void *closure)
   10727             : {
   10728           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   10729           0 :         if (value == NULL) {
   10730           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fWriteAuthorityNs");
   10731           0 :                 return -1;
   10732             :         }
   10733             :         {
   10734           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fWriteAuthorityNs));
   10735           0 :                 if (PyLong_Check(value)) {
   10736           0 :                         unsigned long long test_var;
   10737           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   10738           0 :                         if (PyErr_Occurred() != NULL) {
   10739           0 :                                 return -1;
   10740             :                         }
   10741           0 :                         if (test_var > uint_max) {
   10742           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   10743             :                                   PyLong_Type.tp_name, uint_max, test_var);
   10744           0 :                                 return -1;
   10745             :                         }
   10746           0 :                         object->fWriteAuthorityNs = test_var;
   10747             :                 } else {
   10748           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   10749             :                           PyLong_Type.tp_name);
   10750           0 :                         return -1;
   10751             :                 }
   10752             :         }
   10753           0 :         return 0;
   10754             : }
   10755             : 
   10756           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_fStrictFileParsing(PyObject *obj, void *closure)
   10757             : {
   10758           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   10759           0 :         PyObject *py_fStrictFileParsing;
   10760           1 :         py_fStrictFileParsing = PyLong_FromLong((uint16_t)(object->fStrictFileParsing));
   10761           1 :         return py_fStrictFileParsing;
   10762             : }
   10763             : 
   10764           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_fStrictFileParsing(PyObject *py_obj, PyObject *value, void *closure)
   10765             : {
   10766           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   10767           0 :         if (value == NULL) {
   10768           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fStrictFileParsing");
   10769           0 :                 return -1;
   10770             :         }
   10771             :         {
   10772           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fStrictFileParsing));
   10773           0 :                 if (PyLong_Check(value)) {
   10774           0 :                         unsigned long long test_var;
   10775           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   10776           0 :                         if (PyErr_Occurred() != NULL) {
   10777           0 :                                 return -1;
   10778             :                         }
   10779           0 :                         if (test_var > uint_max) {
   10780           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   10781             :                                   PyLong_Type.tp_name, uint_max, test_var);
   10782           0 :                                 return -1;
   10783             :                         }
   10784           0 :                         object->fStrictFileParsing = test_var;
   10785             :                 } else {
   10786           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   10787             :                           PyLong_Type.tp_name);
   10788           0 :                         return -1;
   10789             :                 }
   10790             :         }
   10791           0 :         return 0;
   10792             : }
   10793             : 
   10794           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_fLooseWildcarding(PyObject *obj, void *closure)
   10795             : {
   10796           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   10797           0 :         PyObject *py_fLooseWildcarding;
   10798           1 :         py_fLooseWildcarding = PyLong_FromLong((uint16_t)(object->fLooseWildcarding));
   10799           1 :         return py_fLooseWildcarding;
   10800             : }
   10801             : 
   10802           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_fLooseWildcarding(PyObject *py_obj, PyObject *value, void *closure)
   10803             : {
   10804           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   10805           0 :         if (value == NULL) {
   10806           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fLooseWildcarding");
   10807           0 :                 return -1;
   10808             :         }
   10809             :         {
   10810           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fLooseWildcarding));
   10811           0 :                 if (PyLong_Check(value)) {
   10812           0 :                         unsigned long long test_var;
   10813           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   10814           0 :                         if (PyErr_Occurred() != NULL) {
   10815           0 :                                 return -1;
   10816             :                         }
   10817           0 :                         if (test_var > uint_max) {
   10818           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   10819             :                                   PyLong_Type.tp_name, uint_max, test_var);
   10820           0 :                                 return -1;
   10821             :                         }
   10822           0 :                         object->fLooseWildcarding = test_var;
   10823             :                 } else {
   10824           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   10825             :                           PyLong_Type.tp_name);
   10826           0 :                         return -1;
   10827             :                 }
   10828             :         }
   10829           0 :         return 0;
   10830             : }
   10831             : 
   10832           1 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_fDefaultAgingState(PyObject *obj, void *closure)
   10833             : {
   10834           1 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   10835           0 :         PyObject *py_fDefaultAgingState;
   10836           1 :         py_fDefaultAgingState = PyLong_FromLong((uint16_t)(object->fDefaultAgingState));
   10837           1 :         return py_fDefaultAgingState;
   10838             : }
   10839             : 
   10840           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_fDefaultAgingState(PyObject *py_obj, PyObject *value, void *closure)
   10841             : {
   10842           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   10843           0 :         if (value == NULL) {
   10844           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fDefaultAgingState");
   10845           0 :                 return -1;
   10846             :         }
   10847             :         {
   10848           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fDefaultAgingState));
   10849           0 :                 if (PyLong_Check(value)) {
   10850           0 :                         unsigned long long test_var;
   10851           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   10852           0 :                         if (PyErr_Occurred() != NULL) {
   10853           0 :                                 return -1;
   10854             :                         }
   10855           0 :                         if (test_var > uint_max) {
   10856           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   10857             :                                   PyLong_Type.tp_name, uint_max, test_var);
   10858           0 :                                 return -1;
   10859             :                         }
   10860           0 :                         object->fDefaultAgingState = test_var;
   10861             :                 } else {
   10862           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   10863             :                           PyLong_Type.tp_name);
   10864           0 :                         return -1;
   10865             :                 }
   10866             :         }
   10867           0 :         return 0;
   10868             : }
   10869             : 
   10870           0 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_get_fReserveArray(PyObject *obj, void *closure)
   10871             : {
   10872           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   10873           0 :         PyObject *py_fReserveArray;
   10874           0 :         py_fReserveArray = PyList_New(15);
   10875           0 :         if (py_fReserveArray == NULL) {
   10876           0 :                 return NULL;
   10877             :         }
   10878             :         {
   10879             :                 int fReserveArray_cntr_0;
   10880           0 :                 for (fReserveArray_cntr_0 = 0; fReserveArray_cntr_0 < (15); fReserveArray_cntr_0++) {
   10881           0 :                         PyObject *py_fReserveArray_0;
   10882           0 :                         py_fReserveArray_0 = PyLong_FromLong((uint16_t)((object->fReserveArray)[fReserveArray_cntr_0]));
   10883           0 :                         PyList_SetItem(py_fReserveArray, fReserveArray_cntr_0, py_fReserveArray_0);
   10884             :                 }
   10885             :         }
   10886           0 :         return py_fReserveArray;
   10887             : }
   10888             : 
   10889           0 : static int py_DNS_RPC_SERVER_INFO_LONGHORN_set_fReserveArray(PyObject *py_obj, PyObject *value, void *closure)
   10890             : {
   10891           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   10892           0 :         if (value == NULL) {
   10893           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fReserveArray");
   10894           0 :                 return -1;
   10895             :         }
   10896           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
   10897             :         {
   10898           0 :                 int fReserveArray_cntr_0;
   10899           0 :                 if (ARRAY_SIZE(object->fReserveArray) != PyList_GET_SIZE(value)) {
   10900           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));
   10901           0 :                         return -1;
   10902             :                 }
   10903           0 :                 for (fReserveArray_cntr_0 = 0; fReserveArray_cntr_0 < PyList_GET_SIZE(value); fReserveArray_cntr_0++) {
   10904           0 :                         if (PyList_GET_ITEM(value, fReserveArray_cntr_0) == NULL) {
   10905           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->fReserveArray)[fReserveArray_cntr_0]");
   10906           0 :                                 return -1;
   10907             :                         }
   10908             :                         {
   10909           0 :                                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof((object->fReserveArray)[fReserveArray_cntr_0]));
   10910           0 :                                 if (PyLong_Check(PyList_GET_ITEM(value, fReserveArray_cntr_0))) {
   10911           0 :                                         unsigned long long test_var;
   10912           0 :                                         test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, fReserveArray_cntr_0));
   10913           0 :                                         if (PyErr_Occurred() != NULL) {
   10914           0 :                                                 return -1;
   10915             :                                         }
   10916           0 :                                         if (test_var > uint_max) {
   10917           0 :                                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   10918             :                                                   PyLong_Type.tp_name, uint_max, test_var);
   10919           0 :                                                 return -1;
   10920             :                                         }
   10921           0 :                                         (object->fReserveArray)[fReserveArray_cntr_0] = test_var;
   10922             :                                 } else {
   10923           0 :                                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   10924             :                                           PyLong_Type.tp_name);
   10925           0 :                                         return -1;
   10926             :                                 }
   10927             :                         }
   10928             :                 }
   10929             :         }
   10930           0 :         return 0;
   10931             : }
   10932             : 
   10933             : static PyGetSetDef py_DNS_RPC_SERVER_INFO_LONGHORN_getsetters[] = {
   10934             :         {
   10935             :                 .name = discard_const_p(char, "dwRpcStructureVersion"),
   10936             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwRpcStructureVersion,
   10937             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwRpcStructureVersion,
   10938             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   10939             :         },
   10940             :         {
   10941             :                 .name = discard_const_p(char, "dwReserved0"),
   10942             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwReserved0,
   10943             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwReserved0,
   10944             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   10945             :         },
   10946             :         {
   10947             :                 .name = discard_const_p(char, "dwVersion"),
   10948             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwVersion,
   10949             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwVersion,
   10950             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   10951             :         },
   10952             :         {
   10953             :                 .name = discard_const_p(char, "fBootMethod"),
   10954             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_fBootMethod,
   10955             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_fBootMethod,
   10956             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_BOOT_METHOD")
   10957             :         },
   10958             :         {
   10959             :                 .name = discard_const_p(char, "fAdminConfigured"),
   10960             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_fAdminConfigured,
   10961             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_fAdminConfigured,
   10962             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   10963             :         },
   10964             :         {
   10965             :                 .name = discard_const_p(char, "fAllowUpdate"),
   10966             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_fAllowUpdate,
   10967             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_fAllowUpdate,
   10968             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   10969             :         },
   10970             :         {
   10971             :                 .name = discard_const_p(char, "fDsAvailable"),
   10972             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_fDsAvailable,
   10973             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_fDsAvailable,
   10974             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   10975             :         },
   10976             :         {
   10977             :                 .name = discard_const_p(char, "pszServerName"),
   10978             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_pszServerName,
   10979             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_pszServerName,
   10980             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   10981             :         },
   10982             :         {
   10983             :                 .name = discard_const_p(char, "pszDsContainer"),
   10984             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_pszDsContainer,
   10985             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_pszDsContainer,
   10986             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
   10987             :         },
   10988             :         {
   10989             :                 .name = discard_const_p(char, "aipServerAddrs"),
   10990             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_aipServerAddrs,
   10991             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_aipServerAddrs,
   10992             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ADDR_ARRAY")
   10993             :         },
   10994             :         {
   10995             :                 .name = discard_const_p(char, "aipListenAddrs"),
   10996             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_aipListenAddrs,
   10997             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_aipListenAddrs,
   10998             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ADDR_ARRAY")
   10999             :         },
   11000             :         {
   11001             :                 .name = discard_const_p(char, "aipForwarders"),
   11002             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_aipForwarders,
   11003             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_aipForwarders,
   11004             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ADDR_ARRAY")
   11005             :         },
   11006             :         {
   11007             :                 .name = discard_const_p(char, "aipLogFilter"),
   11008             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_aipLogFilter,
   11009             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_aipLogFilter,
   11010             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ADDR_ARRAY")
   11011             :         },
   11012             :         {
   11013             :                 .name = discard_const_p(char, "pwszLogFilePath"),
   11014             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_pwszLogFilePath,
   11015             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_pwszLogFilePath,
   11016             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
   11017             :         },
   11018             :         {
   11019             :                 .name = discard_const_p(char, "pszDomainName"),
   11020             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_pszDomainName,
   11021             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_pszDomainName,
   11022             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   11023             :         },
   11024             :         {
   11025             :                 .name = discard_const_p(char, "pszForestName"),
   11026             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_pszForestName,
   11027             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_pszForestName,
   11028             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   11029             :         },
   11030             :         {
   11031             :                 .name = discard_const_p(char, "pszDomainDirectoryPartition"),
   11032             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_pszDomainDirectoryPartition,
   11033             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_pszDomainDirectoryPartition,
   11034             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   11035             :         },
   11036             :         {
   11037             :                 .name = discard_const_p(char, "pszForestDirectoryPartition"),
   11038             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_pszForestDirectoryPartition,
   11039             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_pszForestDirectoryPartition,
   11040             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   11041             :         },
   11042             :         {
   11043             :                 .name = discard_const_p(char, "pExtensions"),
   11044             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_pExtensions,
   11045             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_pExtensions,
   11046             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_EXTENSION")
   11047             :         },
   11048             :         {
   11049             :                 .name = discard_const_p(char, "dwLogLevel"),
   11050             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwLogLevel,
   11051             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwLogLevel,
   11052             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   11053             :         },
   11054             :         {
   11055             :                 .name = discard_const_p(char, "dwDebugLevel"),
   11056             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwDebugLevel,
   11057             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwDebugLevel,
   11058             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   11059             :         },
   11060             :         {
   11061             :                 .name = discard_const_p(char, "dwForwardTimeout"),
   11062             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwForwardTimeout,
   11063             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwForwardTimeout,
   11064             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   11065             :         },
   11066             :         {
   11067             :                 .name = discard_const_p(char, "dwRpcProtocol"),
   11068             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwRpcProtocol,
   11069             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwRpcProtocol,
   11070             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   11071             :         },
   11072             :         {
   11073             :                 .name = discard_const_p(char, "dwNameCheckFlag"),
   11074             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwNameCheckFlag,
   11075             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwNameCheckFlag,
   11076             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_NAME_CHECK_FLAG")
   11077             :         },
   11078             :         {
   11079             :                 .name = discard_const_p(char, "cAddressAnswerLimit"),
   11080             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_cAddressAnswerLimit,
   11081             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_cAddressAnswerLimit,
   11082             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   11083             :         },
   11084             :         {
   11085             :                 .name = discard_const_p(char, "dwRecursionRetry"),
   11086             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwRecursionRetry,
   11087             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwRecursionRetry,
   11088             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   11089             :         },
   11090             :         {
   11091             :                 .name = discard_const_p(char, "dwRecursionTimeout"),
   11092             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwRecursionTimeout,
   11093             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwRecursionTimeout,
   11094             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   11095             :         },
   11096             :         {
   11097             :                 .name = discard_const_p(char, "dwMaxCacheTtl"),
   11098             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwMaxCacheTtl,
   11099             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwMaxCacheTtl,
   11100             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   11101             :         },
   11102             :         {
   11103             :                 .name = discard_const_p(char, "dwDsPollingInterval"),
   11104             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwDsPollingInterval,
   11105             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwDsPollingInterval,
   11106             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   11107             :         },
   11108             :         {
   11109             :                 .name = discard_const_p(char, "dwLocalNetPriorityNetMask"),
   11110             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwLocalNetPriorityNetMask,
   11111             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwLocalNetPriorityNetMask,
   11112             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   11113             :         },
   11114             :         {
   11115             :                 .name = discard_const_p(char, "dwScavengingInterval"),
   11116             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwScavengingInterval,
   11117             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwScavengingInterval,
   11118             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   11119             :         },
   11120             :         {
   11121             :                 .name = discard_const_p(char, "dwDefaultRefreshInterval"),
   11122             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwDefaultRefreshInterval,
   11123             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwDefaultRefreshInterval,
   11124             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   11125             :         },
   11126             :         {
   11127             :                 .name = discard_const_p(char, "dwDefaultNoRefreshInterval"),
   11128             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwDefaultNoRefreshInterval,
   11129             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwDefaultNoRefreshInterval,
   11130             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   11131             :         },
   11132             :         {
   11133             :                 .name = discard_const_p(char, "dwLastScavengeTime"),
   11134             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwLastScavengeTime,
   11135             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwLastScavengeTime,
   11136             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   11137             :         },
   11138             :         {
   11139             :                 .name = discard_const_p(char, "dwEventLogLevel"),
   11140             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwEventLogLevel,
   11141             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwEventLogLevel,
   11142             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   11143             :         },
   11144             :         {
   11145             :                 .name = discard_const_p(char, "dwLogFileMaxSize"),
   11146             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwLogFileMaxSize,
   11147             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwLogFileMaxSize,
   11148             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   11149             :         },
   11150             :         {
   11151             :                 .name = discard_const_p(char, "dwDsForestVersion"),
   11152             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwDsForestVersion,
   11153             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwDsForestVersion,
   11154             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   11155             :         },
   11156             :         {
   11157             :                 .name = discard_const_p(char, "dwDsDomainVersion"),
   11158             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwDsDomainVersion,
   11159             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwDsDomainVersion,
   11160             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   11161             :         },
   11162             :         {
   11163             :                 .name = discard_const_p(char, "dwDsDsaVersion"),
   11164             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwDsDsaVersion,
   11165             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwDsDsaVersion,
   11166             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   11167             :         },
   11168             :         {
   11169             :                 .name = discard_const_p(char, "fReadOnlyDC"),
   11170             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_fReadOnlyDC,
   11171             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_fReadOnlyDC,
   11172             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   11173             :         },
   11174             :         {
   11175             :                 .name = discard_const_p(char, "dwReserveArray"),
   11176             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_dwReserveArray,
   11177             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_dwReserveArray,
   11178             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   11179             :         },
   11180             :         {
   11181             :                 .name = discard_const_p(char, "fAutoReverseZones"),
   11182             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_fAutoReverseZones,
   11183             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_fAutoReverseZones,
   11184             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   11185             :         },
   11186             :         {
   11187             :                 .name = discard_const_p(char, "fAutoCacheUpdate"),
   11188             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_fAutoCacheUpdate,
   11189             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_fAutoCacheUpdate,
   11190             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   11191             :         },
   11192             :         {
   11193             :                 .name = discard_const_p(char, "fRecurseAfterForwarding"),
   11194             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_fRecurseAfterForwarding,
   11195             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_fRecurseAfterForwarding,
   11196             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   11197             :         },
   11198             :         {
   11199             :                 .name = discard_const_p(char, "fForwardDelegations"),
   11200             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_fForwardDelegations,
   11201             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_fForwardDelegations,
   11202             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   11203             :         },
   11204             :         {
   11205             :                 .name = discard_const_p(char, "fNoRecursion"),
   11206             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_fNoRecursion,
   11207             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_fNoRecursion,
   11208             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   11209             :         },
   11210             :         {
   11211             :                 .name = discard_const_p(char, "fSecureResponses"),
   11212             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_fSecureResponses,
   11213             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_fSecureResponses,
   11214             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   11215             :         },
   11216             :         {
   11217             :                 .name = discard_const_p(char, "fRoundRobin"),
   11218             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_fRoundRobin,
   11219             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_fRoundRobin,
   11220             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   11221             :         },
   11222             :         {
   11223             :                 .name = discard_const_p(char, "fLocalNetPriority"),
   11224             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_fLocalNetPriority,
   11225             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_fLocalNetPriority,
   11226             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   11227             :         },
   11228             :         {
   11229             :                 .name = discard_const_p(char, "fBindSecondaries"),
   11230             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_fBindSecondaries,
   11231             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_fBindSecondaries,
   11232             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   11233             :         },
   11234             :         {
   11235             :                 .name = discard_const_p(char, "fWriteAuthorityNs"),
   11236             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_fWriteAuthorityNs,
   11237             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_fWriteAuthorityNs,
   11238             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   11239             :         },
   11240             :         {
   11241             :                 .name = discard_const_p(char, "fStrictFileParsing"),
   11242             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_fStrictFileParsing,
   11243             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_fStrictFileParsing,
   11244             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   11245             :         },
   11246             :         {
   11247             :                 .name = discard_const_p(char, "fLooseWildcarding"),
   11248             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_fLooseWildcarding,
   11249             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_fLooseWildcarding,
   11250             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   11251             :         },
   11252             :         {
   11253             :                 .name = discard_const_p(char, "fDefaultAgingState"),
   11254             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_fDefaultAgingState,
   11255             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_fDefaultAgingState,
   11256             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   11257             :         },
   11258             :         {
   11259             :                 .name = discard_const_p(char, "fReserveArray"),
   11260             :                 .get = py_DNS_RPC_SERVER_INFO_LONGHORN_get_fReserveArray,
   11261             :                 .set = py_DNS_RPC_SERVER_INFO_LONGHORN_set_fReserveArray,
   11262             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   11263             :         },
   11264             :         { .name = NULL }
   11265             : };
   11266             : 
   11267           0 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   11268             : {
   11269           0 :         return pytalloc_new(struct DNS_RPC_SERVER_INFO_LONGHORN, type);
   11270             : }
   11271             : 
   11272           0 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_ndr_pack(PyObject *py_obj,  PyObject *Py_UNUSED(ignored))
   11273             : {
   11274           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   11275           0 :         PyObject *ret = NULL;
   11276           0 :         DATA_BLOB blob;
   11277           0 :         enum ndr_err_code err;
   11278           0 :         TALLOC_CTX *tmp_ctx = talloc_new(pytalloc_get_mem_ctx(py_obj));
   11279           0 :         if (tmp_ctx == NULL) {
   11280           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
   11281           0 :                 return NULL;
   11282             :         }
   11283           0 :         err = ndr_push_struct_blob(&blob, tmp_ctx, object, (ndr_push_flags_fn_t)ndr_push_DNS_RPC_SERVER_INFO_LONGHORN);
   11284           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   11285           0 :                 TALLOC_FREE(tmp_ctx);
   11286           0 :                 PyErr_SetNdrError(err);
   11287           0 :                 return NULL;
   11288             :         }
   11289             : 
   11290           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
   11291           0 :         TALLOC_FREE(tmp_ctx);
   11292           0 :         return ret;
   11293             : }
   11294             : 
   11295           0 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   11296             : {
   11297           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   11298           0 :         DATA_BLOB blob = {.data = NULL, .length = 0};
   11299           0 :         Py_ssize_t blob_length = 0;
   11300           0 :         enum ndr_err_code err;
   11301           0 :         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
   11302           0 :         PyObject *allow_remaining_obj = NULL;
   11303           0 :         bool allow_remaining = false;
   11304             : 
   11305           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|O:__ndr_unpack__",
   11306             :                 discard_const_p(char *, kwnames),
   11307             :                 &blob.data, &blob_length,
   11308             :                 &allow_remaining_obj)) {
   11309           0 :                 return NULL;
   11310             :         }
   11311           0 :         blob.length = blob_length;
   11312             : 
   11313           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
   11314           0 :                 allow_remaining = true;
   11315             :         }
   11316             : 
   11317           0 :         if (allow_remaining) {
   11318           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_LONGHORN);
   11319             :         } else {
   11320           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_LONGHORN);
   11321             :         }
   11322           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   11323           0 :                 PyErr_SetNdrError(err);
   11324           0 :                 return NULL;
   11325             :         }
   11326             : 
   11327           0 :         Py_RETURN_NONE;
   11328             : }
   11329             : 
   11330           0 : static PyObject *py_DNS_RPC_SERVER_INFO_LONGHORN_ndr_print(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
   11331             : {
   11332           0 :         struct DNS_RPC_SERVER_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   11333           0 :         PyObject *ret;
   11334           0 :         char *retstr;
   11335             : 
   11336           0 :         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_DNS_RPC_SERVER_INFO_LONGHORN, "DNS_RPC_SERVER_INFO_LONGHORN", object);
   11337           0 :         ret = PyUnicode_FromString(retstr);
   11338           0 :         talloc_free(retstr);
   11339             : 
   11340           0 :         return ret;
   11341             : }
   11342             : 
   11343             : static PyMethodDef py_DNS_RPC_SERVER_INFO_LONGHORN_methods[] = {
   11344             :         { "__ndr_pack__", (PyCFunction)py_DNS_RPC_SERVER_INFO_LONGHORN_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
   11345             :         { "__ndr_unpack__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DNS_RPC_SERVER_INFO_LONGHORN_ndr_unpack), METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
   11346             :         { "__ndr_print__", (PyCFunction)py_DNS_RPC_SERVER_INFO_LONGHORN_ndr_print, METH_NOARGS, "S.ndr_print(object) -> None\nNDR print" },
   11347             :         { NULL, NULL, 0, NULL }
   11348             : };
   11349             : 
   11350             : 
   11351             : static PyTypeObject DNS_RPC_SERVER_INFO_LONGHORN_Type = {
   11352             :         PyVarObject_HEAD_INIT(NULL, 0)
   11353             :         .tp_name = "dnsserver.DNS_RPC_SERVER_INFO_LONGHORN",
   11354             :         .tp_getset = py_DNS_RPC_SERVER_INFO_LONGHORN_getsetters,
   11355             :         .tp_methods = py_DNS_RPC_SERVER_INFO_LONGHORN_methods,
   11356             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   11357             :         .tp_new = py_DNS_RPC_SERVER_INFO_LONGHORN_new,
   11358             : };
   11359             : 
   11360             : 
   11361           0 : static PyObject *py_DNS_RPC_DP_REPLICA_get_pszReplicaDn(PyObject *obj, void *closure)
   11362             : {
   11363           0 :         struct DNS_RPC_DP_REPLICA *object = pytalloc_get_ptr(obj);
   11364           0 :         PyObject *py_pszReplicaDn;
   11365           0 :         if (object->pszReplicaDn == NULL) {
   11366           0 :                 Py_RETURN_NONE;
   11367             :         }
   11368           0 :         if (object->pszReplicaDn == NULL) {
   11369           0 :                 py_pszReplicaDn = Py_None;
   11370           0 :                 Py_INCREF(py_pszReplicaDn);
   11371             :         } else {
   11372           0 :                 if (object->pszReplicaDn == NULL) {
   11373           0 :                         py_pszReplicaDn = Py_None;
   11374           0 :                         Py_INCREF(py_pszReplicaDn);
   11375             :                 } else {
   11376           0 :                         py_pszReplicaDn = PyUnicode_Decode(object->pszReplicaDn, strlen(object->pszReplicaDn), "utf-8", "ignore");
   11377             :                 }
   11378             :         }
   11379           0 :         return py_pszReplicaDn;
   11380             : }
   11381             : 
   11382           0 : static int py_DNS_RPC_DP_REPLICA_set_pszReplicaDn(PyObject *py_obj, PyObject *value, void *closure)
   11383             : {
   11384           0 :         struct DNS_RPC_DP_REPLICA *object = pytalloc_get_ptr(py_obj);
   11385           0 :         if (value == NULL) {
   11386           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszReplicaDn");
   11387           0 :                 return -1;
   11388             :         }
   11389           0 :         if (value == Py_None) {
   11390           0 :                 object->pszReplicaDn = NULL;
   11391             :         } else {
   11392           0 :                 object->pszReplicaDn = NULL;
   11393             :                 {
   11394           0 :                         const char *test_str;
   11395           0 :                         const char *talloc_str;
   11396           0 :                         PyObject *unicode = NULL;
   11397           0 :                         if (PyUnicode_Check(value)) {
   11398           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   11399           0 :                                 if (unicode == NULL) {
   11400           0 :                                         return -1;
   11401             :                                 }
   11402           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   11403           0 :                         } else if (PyBytes_Check(value)) {
   11404           0 :                                 test_str = PyBytes_AS_STRING(value);
   11405             :                         } else {
   11406           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   11407           0 :                                 return -1;
   11408             :                         }
   11409           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   11410           0 :                         if (unicode != NULL) {
   11411           0 :                                 Py_DECREF(unicode);
   11412             :                         }
   11413           0 :                         if (talloc_str == NULL) {
   11414           0 :                                 PyErr_NoMemory();
   11415           0 :                                 return -1;
   11416             :                         }
   11417           0 :                         object->pszReplicaDn = talloc_str;
   11418             :                 }
   11419             :         }
   11420           0 :         return 0;
   11421             : }
   11422             : 
   11423             : static PyGetSetDef py_DNS_RPC_DP_REPLICA_getsetters[] = {
   11424             :         {
   11425             :                 .name = discard_const_p(char, "pszReplicaDn"),
   11426             :                 .get = py_DNS_RPC_DP_REPLICA_get_pszReplicaDn,
   11427             :                 .set = py_DNS_RPC_DP_REPLICA_set_pszReplicaDn,
   11428             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
   11429             :         },
   11430             :         { .name = NULL }
   11431             : };
   11432             : 
   11433           0 : static PyObject *py_DNS_RPC_DP_REPLICA_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   11434             : {
   11435           0 :         return pytalloc_new(struct DNS_RPC_DP_REPLICA, type);
   11436             : }
   11437             : 
   11438             : 
   11439             : static PyTypeObject DNS_RPC_DP_REPLICA_Type = {
   11440             :         PyVarObject_HEAD_INIT(NULL, 0)
   11441             :         .tp_name = "dnsserver.DNS_RPC_DP_REPLICA",
   11442             :         .tp_getset = py_DNS_RPC_DP_REPLICA_getsetters,
   11443             :         .tp_methods = NULL,
   11444             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   11445             :         .tp_new = py_DNS_RPC_DP_REPLICA_new,
   11446             : };
   11447             : 
   11448             : 
   11449           0 : static PyObject *py_DNS_RPC_DP_INFO_get_dwRpcStructureVersion(PyObject *obj, void *closure)
   11450             : {
   11451           0 :         struct DNS_RPC_DP_INFO *object = pytalloc_get_ptr(obj);
   11452           0 :         PyObject *py_dwRpcStructureVersion;
   11453           0 :         py_dwRpcStructureVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcStructureVersion));
   11454           0 :         return py_dwRpcStructureVersion;
   11455             : }
   11456             : 
   11457           0 : static int py_DNS_RPC_DP_INFO_set_dwRpcStructureVersion(PyObject *py_obj, PyObject *value, void *closure)
   11458             : {
   11459           0 :         struct DNS_RPC_DP_INFO *object = pytalloc_get_ptr(py_obj);
   11460           0 :         if (value == NULL) {
   11461           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcStructureVersion");
   11462           0 :                 return -1;
   11463             :         }
   11464             :         {
   11465           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcStructureVersion));
   11466           0 :                 if (PyLong_Check(value)) {
   11467           0 :                         unsigned long long test_var;
   11468           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   11469           0 :                         if (PyErr_Occurred() != NULL) {
   11470           0 :                                 return -1;
   11471             :                         }
   11472           0 :                         if (test_var > uint_max) {
   11473           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   11474             :                                   PyLong_Type.tp_name, uint_max, test_var);
   11475           0 :                                 return -1;
   11476             :                         }
   11477           0 :                         object->dwRpcStructureVersion = test_var;
   11478             :                 } else {
   11479           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   11480             :                           PyLong_Type.tp_name);
   11481           0 :                         return -1;
   11482             :                 }
   11483             :         }
   11484           0 :         return 0;
   11485             : }
   11486             : 
   11487           0 : static PyObject *py_DNS_RPC_DP_INFO_get_dwReserved0(PyObject *obj, void *closure)
   11488             : {
   11489           0 :         struct DNS_RPC_DP_INFO *object = pytalloc_get_ptr(obj);
   11490           0 :         PyObject *py_dwReserved0;
   11491           0 :         py_dwReserved0 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved0));
   11492           0 :         return py_dwReserved0;
   11493             : }
   11494             : 
   11495           0 : static int py_DNS_RPC_DP_INFO_set_dwReserved0(PyObject *py_obj, PyObject *value, void *closure)
   11496             : {
   11497           0 :         struct DNS_RPC_DP_INFO *object = pytalloc_get_ptr(py_obj);
   11498           0 :         if (value == NULL) {
   11499           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved0");
   11500           0 :                 return -1;
   11501             :         }
   11502             :         {
   11503           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved0));
   11504           0 :                 if (PyLong_Check(value)) {
   11505           0 :                         unsigned long long test_var;
   11506           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   11507           0 :                         if (PyErr_Occurred() != NULL) {
   11508           0 :                                 return -1;
   11509             :                         }
   11510           0 :                         if (test_var > uint_max) {
   11511           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   11512             :                                   PyLong_Type.tp_name, uint_max, test_var);
   11513           0 :                                 return -1;
   11514             :                         }
   11515           0 :                         object->dwReserved0 = test_var;
   11516             :                 } else {
   11517           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   11518             :                           PyLong_Type.tp_name);
   11519           0 :                         return -1;
   11520             :                 }
   11521             :         }
   11522           0 :         return 0;
   11523             : }
   11524             : 
   11525           0 : static PyObject *py_DNS_RPC_DP_INFO_get_pszDpFqdn(PyObject *obj, void *closure)
   11526             : {
   11527           0 :         struct DNS_RPC_DP_INFO *object = pytalloc_get_ptr(obj);
   11528           0 :         PyObject *py_pszDpFqdn;
   11529           0 :         if (object->pszDpFqdn == NULL) {
   11530           0 :                 Py_RETURN_NONE;
   11531             :         }
   11532           0 :         if (object->pszDpFqdn == NULL) {
   11533           0 :                 py_pszDpFqdn = Py_None;
   11534           0 :                 Py_INCREF(py_pszDpFqdn);
   11535             :         } else {
   11536           0 :                 if (object->pszDpFqdn == NULL) {
   11537           0 :                         py_pszDpFqdn = Py_None;
   11538           0 :                         Py_INCREF(py_pszDpFqdn);
   11539             :                 } else {
   11540           0 :                         py_pszDpFqdn = PyUnicode_Decode(object->pszDpFqdn, strlen(object->pszDpFqdn), "utf-8", "ignore");
   11541             :                 }
   11542             :         }
   11543           0 :         return py_pszDpFqdn;
   11544             : }
   11545             : 
   11546           0 : static int py_DNS_RPC_DP_INFO_set_pszDpFqdn(PyObject *py_obj, PyObject *value, void *closure)
   11547             : {
   11548           0 :         struct DNS_RPC_DP_INFO *object = pytalloc_get_ptr(py_obj);
   11549           0 :         if (value == NULL) {
   11550           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszDpFqdn");
   11551           0 :                 return -1;
   11552             :         }
   11553           0 :         if (value == Py_None) {
   11554           0 :                 object->pszDpFqdn = NULL;
   11555             :         } else {
   11556           0 :                 object->pszDpFqdn = NULL;
   11557             :                 {
   11558           0 :                         const char *test_str;
   11559           0 :                         const char *talloc_str;
   11560           0 :                         PyObject *unicode = NULL;
   11561           0 :                         if (PyUnicode_Check(value)) {
   11562           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   11563           0 :                                 if (unicode == NULL) {
   11564           0 :                                         return -1;
   11565             :                                 }
   11566           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   11567           0 :                         } else if (PyBytes_Check(value)) {
   11568           0 :                                 test_str = PyBytes_AS_STRING(value);
   11569             :                         } else {
   11570           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   11571           0 :                                 return -1;
   11572             :                         }
   11573           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   11574           0 :                         if (unicode != NULL) {
   11575           0 :                                 Py_DECREF(unicode);
   11576             :                         }
   11577           0 :                         if (talloc_str == NULL) {
   11578           0 :                                 PyErr_NoMemory();
   11579           0 :                                 return -1;
   11580             :                         }
   11581           0 :                         object->pszDpFqdn = talloc_str;
   11582             :                 }
   11583             :         }
   11584           0 :         return 0;
   11585             : }
   11586             : 
   11587           0 : static PyObject *py_DNS_RPC_DP_INFO_get_pszDpDn(PyObject *obj, void *closure)
   11588             : {
   11589           0 :         struct DNS_RPC_DP_INFO *object = pytalloc_get_ptr(obj);
   11590           0 :         PyObject *py_pszDpDn;
   11591           0 :         if (object->pszDpDn == NULL) {
   11592           0 :                 Py_RETURN_NONE;
   11593             :         }
   11594           0 :         if (object->pszDpDn == NULL) {
   11595           0 :                 py_pszDpDn = Py_None;
   11596           0 :                 Py_INCREF(py_pszDpDn);
   11597             :         } else {
   11598           0 :                 if (object->pszDpDn == NULL) {
   11599           0 :                         py_pszDpDn = Py_None;
   11600           0 :                         Py_INCREF(py_pszDpDn);
   11601             :                 } else {
   11602           0 :                         py_pszDpDn = PyUnicode_Decode(object->pszDpDn, strlen(object->pszDpDn), "utf-8", "ignore");
   11603             :                 }
   11604             :         }
   11605           0 :         return py_pszDpDn;
   11606             : }
   11607             : 
   11608           0 : static int py_DNS_RPC_DP_INFO_set_pszDpDn(PyObject *py_obj, PyObject *value, void *closure)
   11609             : {
   11610           0 :         struct DNS_RPC_DP_INFO *object = pytalloc_get_ptr(py_obj);
   11611           0 :         if (value == NULL) {
   11612           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszDpDn");
   11613           0 :                 return -1;
   11614             :         }
   11615           0 :         if (value == Py_None) {
   11616           0 :                 object->pszDpDn = NULL;
   11617             :         } else {
   11618           0 :                 object->pszDpDn = NULL;
   11619             :                 {
   11620           0 :                         const char *test_str;
   11621           0 :                         const char *talloc_str;
   11622           0 :                         PyObject *unicode = NULL;
   11623           0 :                         if (PyUnicode_Check(value)) {
   11624           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   11625           0 :                                 if (unicode == NULL) {
   11626           0 :                                         return -1;
   11627             :                                 }
   11628           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   11629           0 :                         } else if (PyBytes_Check(value)) {
   11630           0 :                                 test_str = PyBytes_AS_STRING(value);
   11631             :                         } else {
   11632           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   11633           0 :                                 return -1;
   11634             :                         }
   11635           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   11636           0 :                         if (unicode != NULL) {
   11637           0 :                                 Py_DECREF(unicode);
   11638             :                         }
   11639           0 :                         if (talloc_str == NULL) {
   11640           0 :                                 PyErr_NoMemory();
   11641           0 :                                 return -1;
   11642             :                         }
   11643           0 :                         object->pszDpDn = talloc_str;
   11644             :                 }
   11645             :         }
   11646           0 :         return 0;
   11647             : }
   11648             : 
   11649           0 : static PyObject *py_DNS_RPC_DP_INFO_get_pszCrDn(PyObject *obj, void *closure)
   11650             : {
   11651           0 :         struct DNS_RPC_DP_INFO *object = pytalloc_get_ptr(obj);
   11652           0 :         PyObject *py_pszCrDn;
   11653           0 :         if (object->pszCrDn == NULL) {
   11654           0 :                 Py_RETURN_NONE;
   11655             :         }
   11656           0 :         if (object->pszCrDn == NULL) {
   11657           0 :                 py_pszCrDn = Py_None;
   11658           0 :                 Py_INCREF(py_pszCrDn);
   11659             :         } else {
   11660           0 :                 if (object->pszCrDn == NULL) {
   11661           0 :                         py_pszCrDn = Py_None;
   11662           0 :                         Py_INCREF(py_pszCrDn);
   11663             :                 } else {
   11664           0 :                         py_pszCrDn = PyUnicode_Decode(object->pszCrDn, strlen(object->pszCrDn), "utf-8", "ignore");
   11665             :                 }
   11666             :         }
   11667           0 :         return py_pszCrDn;
   11668             : }
   11669             : 
   11670           0 : static int py_DNS_RPC_DP_INFO_set_pszCrDn(PyObject *py_obj, PyObject *value, void *closure)
   11671             : {
   11672           0 :         struct DNS_RPC_DP_INFO *object = pytalloc_get_ptr(py_obj);
   11673           0 :         if (value == NULL) {
   11674           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszCrDn");
   11675           0 :                 return -1;
   11676             :         }
   11677           0 :         if (value == Py_None) {
   11678           0 :                 object->pszCrDn = NULL;
   11679             :         } else {
   11680           0 :                 object->pszCrDn = NULL;
   11681             :                 {
   11682           0 :                         const char *test_str;
   11683           0 :                         const char *talloc_str;
   11684           0 :                         PyObject *unicode = NULL;
   11685           0 :                         if (PyUnicode_Check(value)) {
   11686           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   11687           0 :                                 if (unicode == NULL) {
   11688           0 :                                         return -1;
   11689             :                                 }
   11690           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   11691           0 :                         } else if (PyBytes_Check(value)) {
   11692           0 :                                 test_str = PyBytes_AS_STRING(value);
   11693             :                         } else {
   11694           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   11695           0 :                                 return -1;
   11696             :                         }
   11697           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   11698           0 :                         if (unicode != NULL) {
   11699           0 :                                 Py_DECREF(unicode);
   11700             :                         }
   11701           0 :                         if (talloc_str == NULL) {
   11702           0 :                                 PyErr_NoMemory();
   11703           0 :                                 return -1;
   11704             :                         }
   11705           0 :                         object->pszCrDn = talloc_str;
   11706             :                 }
   11707             :         }
   11708           0 :         return 0;
   11709             : }
   11710             : 
   11711           0 : static PyObject *py_DNS_RPC_DP_INFO_get_dwFlags(PyObject *obj, void *closure)
   11712             : {
   11713           0 :         struct DNS_RPC_DP_INFO *object = pytalloc_get_ptr(obj);
   11714           0 :         PyObject *py_dwFlags;
   11715           0 :         py_dwFlags = PyLong_FromUnsignedLongLong((uint32_t)(object->dwFlags));
   11716           0 :         return py_dwFlags;
   11717             : }
   11718             : 
   11719           0 : static int py_DNS_RPC_DP_INFO_set_dwFlags(PyObject *py_obj, PyObject *value, void *closure)
   11720             : {
   11721           0 :         struct DNS_RPC_DP_INFO *object = pytalloc_get_ptr(py_obj);
   11722           0 :         if (value == NULL) {
   11723           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwFlags");
   11724           0 :                 return -1;
   11725             :         }
   11726             :         {
   11727           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwFlags));
   11728           0 :                 if (PyLong_Check(value)) {
   11729           0 :                         unsigned long long test_var;
   11730           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   11731           0 :                         if (PyErr_Occurred() != NULL) {
   11732           0 :                                 return -1;
   11733             :                         }
   11734           0 :                         if (test_var > uint_max) {
   11735           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   11736             :                                   PyLong_Type.tp_name, uint_max, test_var);
   11737           0 :                                 return -1;
   11738             :                         }
   11739           0 :                         object->dwFlags = test_var;
   11740             :                 } else {
   11741           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   11742             :                           PyLong_Type.tp_name);
   11743           0 :                         return -1;
   11744             :                 }
   11745             :         }
   11746           0 :         return 0;
   11747             : }
   11748             : 
   11749           0 : static PyObject *py_DNS_RPC_DP_INFO_get_dwZoneCount(PyObject *obj, void *closure)
   11750             : {
   11751           0 :         struct DNS_RPC_DP_INFO *object = pytalloc_get_ptr(obj);
   11752           0 :         PyObject *py_dwZoneCount;
   11753           0 :         py_dwZoneCount = PyLong_FromUnsignedLongLong((uint32_t)(object->dwZoneCount));
   11754           0 :         return py_dwZoneCount;
   11755             : }
   11756             : 
   11757           0 : static int py_DNS_RPC_DP_INFO_set_dwZoneCount(PyObject *py_obj, PyObject *value, void *closure)
   11758             : {
   11759           0 :         struct DNS_RPC_DP_INFO *object = pytalloc_get_ptr(py_obj);
   11760           0 :         if (value == NULL) {
   11761           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwZoneCount");
   11762           0 :                 return -1;
   11763             :         }
   11764             :         {
   11765           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwZoneCount));
   11766           0 :                 if (PyLong_Check(value)) {
   11767           0 :                         unsigned long long test_var;
   11768           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   11769           0 :                         if (PyErr_Occurred() != NULL) {
   11770           0 :                                 return -1;
   11771             :                         }
   11772           0 :                         if (test_var > uint_max) {
   11773           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   11774             :                                   PyLong_Type.tp_name, uint_max, test_var);
   11775           0 :                                 return -1;
   11776             :                         }
   11777           0 :                         object->dwZoneCount = test_var;
   11778             :                 } else {
   11779           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   11780             :                           PyLong_Type.tp_name);
   11781           0 :                         return -1;
   11782             :                 }
   11783             :         }
   11784           0 :         return 0;
   11785             : }
   11786             : 
   11787           0 : static PyObject *py_DNS_RPC_DP_INFO_get_dwState(PyObject *obj, void *closure)
   11788             : {
   11789           0 :         struct DNS_RPC_DP_INFO *object = pytalloc_get_ptr(obj);
   11790           0 :         PyObject *py_dwState;
   11791           0 :         py_dwState = PyLong_FromUnsignedLongLong((uint32_t)(object->dwState));
   11792           0 :         return py_dwState;
   11793             : }
   11794             : 
   11795           0 : static int py_DNS_RPC_DP_INFO_set_dwState(PyObject *py_obj, PyObject *value, void *closure)
   11796             : {
   11797           0 :         struct DNS_RPC_DP_INFO *object = pytalloc_get_ptr(py_obj);
   11798           0 :         if (value == NULL) {
   11799           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwState");
   11800           0 :                 return -1;
   11801             :         }
   11802             :         {
   11803           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwState));
   11804           0 :                 if (PyLong_Check(value)) {
   11805           0 :                         unsigned long long test_var;
   11806           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   11807           0 :                         if (PyErr_Occurred() != NULL) {
   11808           0 :                                 return -1;
   11809             :                         }
   11810           0 :                         if (test_var > uint_max) {
   11811           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   11812             :                                   PyLong_Type.tp_name, uint_max, test_var);
   11813           0 :                                 return -1;
   11814             :                         }
   11815           0 :                         object->dwState = test_var;
   11816             :                 } else {
   11817           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   11818             :                           PyLong_Type.tp_name);
   11819           0 :                         return -1;
   11820             :                 }
   11821             :         }
   11822           0 :         return 0;
   11823             : }
   11824             : 
   11825           0 : static PyObject *py_DNS_RPC_DP_INFO_get_dwReserved(PyObject *obj, void *closure)
   11826             : {
   11827           0 :         struct DNS_RPC_DP_INFO *object = pytalloc_get_ptr(obj);
   11828           0 :         PyObject *py_dwReserved;
   11829           0 :         py_dwReserved = PyList_New(3);
   11830           0 :         if (py_dwReserved == NULL) {
   11831           0 :                 return NULL;
   11832             :         }
   11833             :         {
   11834             :                 int dwReserved_cntr_0;
   11835           0 :                 for (dwReserved_cntr_0 = 0; dwReserved_cntr_0 < (3); dwReserved_cntr_0++) {
   11836           0 :                         PyObject *py_dwReserved_0;
   11837           0 :                         py_dwReserved_0 = PyLong_FromUnsignedLongLong((uint32_t)((object->dwReserved)[dwReserved_cntr_0]));
   11838           0 :                         PyList_SetItem(py_dwReserved, dwReserved_cntr_0, py_dwReserved_0);
   11839             :                 }
   11840             :         }
   11841           0 :         return py_dwReserved;
   11842             : }
   11843             : 
   11844           0 : static int py_DNS_RPC_DP_INFO_set_dwReserved(PyObject *py_obj, PyObject *value, void *closure)
   11845             : {
   11846           0 :         struct DNS_RPC_DP_INFO *object = pytalloc_get_ptr(py_obj);
   11847           0 :         if (value == NULL) {
   11848           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved");
   11849           0 :                 return -1;
   11850             :         }
   11851           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
   11852             :         {
   11853           0 :                 int dwReserved_cntr_0;
   11854           0 :                 if (ARRAY_SIZE(object->dwReserved) != PyList_GET_SIZE(value)) {
   11855           0 :                         PyErr_Format(PyExc_TypeError, "Expected list of type %s, length %zu, got %zd", Py_TYPE(value)->tp_name, ARRAY_SIZE(object->dwReserved),  PyList_GET_SIZE(value));
   11856           0 :                         return -1;
   11857             :                 }
   11858           0 :                 for (dwReserved_cntr_0 = 0; dwReserved_cntr_0 < PyList_GET_SIZE(value); dwReserved_cntr_0++) {
   11859           0 :                         if (PyList_GET_ITEM(value, dwReserved_cntr_0) == NULL) {
   11860           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->dwReserved)[dwReserved_cntr_0]");
   11861           0 :                                 return -1;
   11862             :                         }
   11863             :                         {
   11864           0 :                                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof((object->dwReserved)[dwReserved_cntr_0]));
   11865           0 :                                 if (PyLong_Check(PyList_GET_ITEM(value, dwReserved_cntr_0))) {
   11866           0 :                                         unsigned long long test_var;
   11867           0 :                                         test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, dwReserved_cntr_0));
   11868           0 :                                         if (PyErr_Occurred() != NULL) {
   11869           0 :                                                 return -1;
   11870             :                                         }
   11871           0 :                                         if (test_var > uint_max) {
   11872           0 :                                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   11873             :                                                   PyLong_Type.tp_name, uint_max, test_var);
   11874           0 :                                                 return -1;
   11875             :                                         }
   11876           0 :                                         (object->dwReserved)[dwReserved_cntr_0] = test_var;
   11877             :                                 } else {
   11878           0 :                                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   11879             :                                           PyLong_Type.tp_name);
   11880           0 :                                         return -1;
   11881             :                                 }
   11882             :                         }
   11883             :                 }
   11884             :         }
   11885           0 :         return 0;
   11886             : }
   11887             : 
   11888           0 : static PyObject *py_DNS_RPC_DP_INFO_get_pwszReserved(PyObject *obj, void *closure)
   11889             : {
   11890           0 :         struct DNS_RPC_DP_INFO *object = pytalloc_get_ptr(obj);
   11891           0 :         PyObject *py_pwszReserved;
   11892           0 :         py_pwszReserved = PyList_New(3);
   11893           0 :         if (py_pwszReserved == NULL) {
   11894           0 :                 return NULL;
   11895             :         }
   11896             :         {
   11897             :                 int pwszReserved_cntr_0;
   11898           0 :                 for (pwszReserved_cntr_0 = 0; pwszReserved_cntr_0 < (3); pwszReserved_cntr_0++) {
   11899           0 :                         PyObject *py_pwszReserved_0;
   11900           0 :                         py_pwszReserved_0 = pytalloc_reference_ex(&DNS_EXTENSION_Type, pytalloc_get_mem_ctx(obj), &(object->pwszReserved)[pwszReserved_cntr_0]);
   11901           0 :                         PyList_SetItem(py_pwszReserved, pwszReserved_cntr_0, py_pwszReserved_0);
   11902             :                 }
   11903             :         }
   11904           0 :         return py_pwszReserved;
   11905             : }
   11906             : 
   11907           0 : static int py_DNS_RPC_DP_INFO_set_pwszReserved(PyObject *py_obj, PyObject *value, void *closure)
   11908             : {
   11909           0 :         struct DNS_RPC_DP_INFO *object = pytalloc_get_ptr(py_obj);
   11910           0 :         if (value == NULL) {
   11911           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pwszReserved");
   11912           0 :                 return -1;
   11913             :         }
   11914           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
   11915             :         {
   11916           0 :                 int pwszReserved_cntr_0;
   11917           0 :                 if (ARRAY_SIZE(object->pwszReserved) != PyList_GET_SIZE(value)) {
   11918           0 :                         PyErr_Format(PyExc_TypeError, "Expected list of type %s, length %zu, got %zd", Py_TYPE(value)->tp_name, ARRAY_SIZE(object->pwszReserved),  PyList_GET_SIZE(value));
   11919           0 :                         return -1;
   11920             :                 }
   11921           0 :                 for (pwszReserved_cntr_0 = 0; pwszReserved_cntr_0 < PyList_GET_SIZE(value); pwszReserved_cntr_0++) {
   11922           0 :                         if (PyList_GET_ITEM(value, pwszReserved_cntr_0) == NULL) {
   11923           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->pwszReserved)[pwszReserved_cntr_0]");
   11924           0 :                                 return -1;
   11925             :                         }
   11926           0 :                         PY_CHECK_TYPE(&DNS_EXTENSION_Type, PyList_GET_ITEM(value, pwszReserved_cntr_0), return -1;);
   11927           0 :                         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(PyList_GET_ITEM(value, pwszReserved_cntr_0))) == NULL) {
   11928           0 :                                 PyErr_NoMemory();
   11929           0 :                                 return -1;
   11930             :                         }
   11931           0 :                         (object->pwszReserved)[pwszReserved_cntr_0] = *(struct DNS_EXTENSION *)pytalloc_get_ptr(PyList_GET_ITEM(value, pwszReserved_cntr_0));
   11932             :                 }
   11933             :         }
   11934           0 :         return 0;
   11935             : }
   11936             : 
   11937           0 : static PyObject *py_DNS_RPC_DP_INFO_get_dwReplicaCount(PyObject *obj, void *closure)
   11938             : {
   11939           0 :         struct DNS_RPC_DP_INFO *object = pytalloc_get_ptr(obj);
   11940           0 :         PyObject *py_dwReplicaCount;
   11941           0 :         py_dwReplicaCount = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReplicaCount));
   11942           0 :         return py_dwReplicaCount;
   11943             : }
   11944             : 
   11945           0 : static int py_DNS_RPC_DP_INFO_set_dwReplicaCount(PyObject *py_obj, PyObject *value, void *closure)
   11946             : {
   11947           0 :         struct DNS_RPC_DP_INFO *object = pytalloc_get_ptr(py_obj);
   11948           0 :         if (value == NULL) {
   11949           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReplicaCount");
   11950           0 :                 return -1;
   11951             :         }
   11952             :         {
   11953           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReplicaCount));
   11954           0 :                 if (PyLong_Check(value)) {
   11955           0 :                         unsigned long long test_var;
   11956           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   11957           0 :                         if (PyErr_Occurred() != NULL) {
   11958           0 :                                 return -1;
   11959             :                         }
   11960           0 :                         if (test_var > uint_max) {
   11961           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   11962             :                                   PyLong_Type.tp_name, uint_max, test_var);
   11963           0 :                                 return -1;
   11964             :                         }
   11965           0 :                         object->dwReplicaCount = test_var;
   11966             :                 } else {
   11967           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   11968             :                           PyLong_Type.tp_name);
   11969           0 :                         return -1;
   11970             :                 }
   11971             :         }
   11972           0 :         return 0;
   11973             : }
   11974             : 
   11975           0 : static PyObject *py_DNS_RPC_DP_INFO_get_ReplicaArray(PyObject *obj, void *closure)
   11976             : {
   11977           0 :         struct DNS_RPC_DP_INFO *object = pytalloc_get_ptr(obj);
   11978           0 :         PyObject *py_ReplicaArray;
   11979           0 :         py_ReplicaArray = PyList_New(object->dwReplicaCount);
   11980           0 :         if (py_ReplicaArray == NULL) {
   11981           0 :                 return NULL;
   11982             :         }
   11983             :         {
   11984             :                 int ReplicaArray_cntr_0;
   11985           0 :                 for (ReplicaArray_cntr_0 = 0; ReplicaArray_cntr_0 < (object->dwReplicaCount); ReplicaArray_cntr_0++) {
   11986           0 :                         PyObject *py_ReplicaArray_0;
   11987           0 :                         if ((object->ReplicaArray)[ReplicaArray_cntr_0] == NULL) {
   11988           0 :                                 py_ReplicaArray_0 = Py_None;
   11989           0 :                                 Py_INCREF(py_ReplicaArray_0);
   11990             :                         } else {
   11991           0 :                                 py_ReplicaArray_0 = pytalloc_reference_ex(&DNS_RPC_DP_REPLICA_Type, (object->ReplicaArray)[ReplicaArray_cntr_0], (object->ReplicaArray)[ReplicaArray_cntr_0]);
   11992             :                         }
   11993           0 :                         PyList_SetItem(py_ReplicaArray, ReplicaArray_cntr_0, py_ReplicaArray_0);
   11994             :                 }
   11995             :         }
   11996           0 :         return py_ReplicaArray;
   11997             : }
   11998             : 
   11999           0 : static int py_DNS_RPC_DP_INFO_set_ReplicaArray(PyObject *py_obj, PyObject *value, void *closure)
   12000             : {
   12001           0 :         struct DNS_RPC_DP_INFO *object = pytalloc_get_ptr(py_obj);
   12002           0 :         if (value == NULL) {
   12003           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->ReplicaArray");
   12004           0 :                 return -1;
   12005             :         }
   12006           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
   12007             :         {
   12008           0 :                 int ReplicaArray_cntr_0;
   12009           0 :                 object->ReplicaArray = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->ReplicaArray, PyList_GET_SIZE(value));
   12010           0 :                 if (!object->ReplicaArray) { return -1; }
   12011           0 :                 talloc_set_name_const(object->ReplicaArray, "ARRAY: object->ReplicaArray");
   12012           0 :                 for (ReplicaArray_cntr_0 = 0; ReplicaArray_cntr_0 < PyList_GET_SIZE(value); ReplicaArray_cntr_0++) {
   12013           0 :                         if (PyList_GET_ITEM(value, ReplicaArray_cntr_0) == NULL) {
   12014           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->ReplicaArray)[ReplicaArray_cntr_0]");
   12015           0 :                                 return -1;
   12016             :                         }
   12017           0 :                         if (PyList_GET_ITEM(value, ReplicaArray_cntr_0) == Py_None) {
   12018           0 :                                 (object->ReplicaArray)[ReplicaArray_cntr_0] = NULL;
   12019             :                         } else {
   12020           0 :                                 (object->ReplicaArray)[ReplicaArray_cntr_0] = NULL;
   12021           0 :                                 PY_CHECK_TYPE(&DNS_RPC_DP_REPLICA_Type, PyList_GET_ITEM(value, ReplicaArray_cntr_0), return -1;);
   12022           0 :                                 if (talloc_reference(object->ReplicaArray, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, ReplicaArray_cntr_0))) == NULL) {
   12023           0 :                                         PyErr_NoMemory();
   12024           0 :                                         return -1;
   12025             :                                 }
   12026           0 :                                 (object->ReplicaArray)[ReplicaArray_cntr_0] = (struct DNS_RPC_DP_REPLICA *)pytalloc_get_ptr(PyList_GET_ITEM(value, ReplicaArray_cntr_0));
   12027             :                         }
   12028             :                 }
   12029             :         }
   12030           0 :         return 0;
   12031             : }
   12032             : 
   12033             : static PyGetSetDef py_DNS_RPC_DP_INFO_getsetters[] = {
   12034             :         {
   12035             :                 .name = discard_const_p(char, "dwRpcStructureVersion"),
   12036             :                 .get = py_DNS_RPC_DP_INFO_get_dwRpcStructureVersion,
   12037             :                 .set = py_DNS_RPC_DP_INFO_set_dwRpcStructureVersion,
   12038             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   12039             :         },
   12040             :         {
   12041             :                 .name = discard_const_p(char, "dwReserved0"),
   12042             :                 .get = py_DNS_RPC_DP_INFO_get_dwReserved0,
   12043             :                 .set = py_DNS_RPC_DP_INFO_set_dwReserved0,
   12044             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   12045             :         },
   12046             :         {
   12047             :                 .name = discard_const_p(char, "pszDpFqdn"),
   12048             :                 .get = py_DNS_RPC_DP_INFO_get_pszDpFqdn,
   12049             :                 .set = py_DNS_RPC_DP_INFO_set_pszDpFqdn,
   12050             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   12051             :         },
   12052             :         {
   12053             :                 .name = discard_const_p(char, "pszDpDn"),
   12054             :                 .get = py_DNS_RPC_DP_INFO_get_pszDpDn,
   12055             :                 .set = py_DNS_RPC_DP_INFO_set_pszDpDn,
   12056             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
   12057             :         },
   12058             :         {
   12059             :                 .name = discard_const_p(char, "pszCrDn"),
   12060             :                 .get = py_DNS_RPC_DP_INFO_get_pszCrDn,
   12061             :                 .set = py_DNS_RPC_DP_INFO_set_pszCrDn,
   12062             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
   12063             :         },
   12064             :         {
   12065             :                 .name = discard_const_p(char, "dwFlags"),
   12066             :                 .get = py_DNS_RPC_DP_INFO_get_dwFlags,
   12067             :                 .set = py_DNS_RPC_DP_INFO_set_dwFlags,
   12068             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   12069             :         },
   12070             :         {
   12071             :                 .name = discard_const_p(char, "dwZoneCount"),
   12072             :                 .get = py_DNS_RPC_DP_INFO_get_dwZoneCount,
   12073             :                 .set = py_DNS_RPC_DP_INFO_set_dwZoneCount,
   12074             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   12075             :         },
   12076             :         {
   12077             :                 .name = discard_const_p(char, "dwState"),
   12078             :                 .get = py_DNS_RPC_DP_INFO_get_dwState,
   12079             :                 .set = py_DNS_RPC_DP_INFO_set_dwState,
   12080             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_DP_STATE")
   12081             :         },
   12082             :         {
   12083             :                 .name = discard_const_p(char, "dwReserved"),
   12084             :                 .get = py_DNS_RPC_DP_INFO_get_dwReserved,
   12085             :                 .set = py_DNS_RPC_DP_INFO_set_dwReserved,
   12086             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   12087             :         },
   12088             :         {
   12089             :                 .name = discard_const_p(char, "pwszReserved"),
   12090             :                 .get = py_DNS_RPC_DP_INFO_get_pwszReserved,
   12091             :                 .set = py_DNS_RPC_DP_INFO_set_pwszReserved,
   12092             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_EXTENSION")
   12093             :         },
   12094             :         {
   12095             :                 .name = discard_const_p(char, "dwReplicaCount"),
   12096             :                 .get = py_DNS_RPC_DP_INFO_get_dwReplicaCount,
   12097             :                 .set = py_DNS_RPC_DP_INFO_set_dwReplicaCount,
   12098             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   12099             :         },
   12100             :         {
   12101             :                 .name = discard_const_p(char, "ReplicaArray"),
   12102             :                 .get = py_DNS_RPC_DP_INFO_get_ReplicaArray,
   12103             :                 .set = py_DNS_RPC_DP_INFO_set_ReplicaArray,
   12104             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_DP_REPLICA")
   12105             :         },
   12106             :         { .name = NULL }
   12107             : };
   12108             : 
   12109           0 : static PyObject *py_DNS_RPC_DP_INFO_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   12110             : {
   12111           0 :         return pytalloc_new(struct DNS_RPC_DP_INFO, type);
   12112             : }
   12113             : 
   12114             : 
   12115             : static PyTypeObject DNS_RPC_DP_INFO_Type = {
   12116             :         PyVarObject_HEAD_INIT(NULL, 0)
   12117             :         .tp_name = "dnsserver.DNS_RPC_DP_INFO",
   12118             :         .tp_getset = py_DNS_RPC_DP_INFO_getsetters,
   12119             :         .tp_methods = NULL,
   12120             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   12121             :         .tp_new = py_DNS_RPC_DP_INFO_new,
   12122             : };
   12123             : 
   12124             : 
   12125           0 : static PyObject *py_DNS_RPC_DP_ENUM_get_dwRpcStructureVersion(PyObject *obj, void *closure)
   12126             : {
   12127           0 :         struct DNS_RPC_DP_ENUM *object = pytalloc_get_ptr(obj);
   12128           0 :         PyObject *py_dwRpcStructureVersion;
   12129           0 :         py_dwRpcStructureVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcStructureVersion));
   12130           0 :         return py_dwRpcStructureVersion;
   12131             : }
   12132             : 
   12133           0 : static int py_DNS_RPC_DP_ENUM_set_dwRpcStructureVersion(PyObject *py_obj, PyObject *value, void *closure)
   12134             : {
   12135           0 :         struct DNS_RPC_DP_ENUM *object = pytalloc_get_ptr(py_obj);
   12136           0 :         if (value == NULL) {
   12137           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcStructureVersion");
   12138           0 :                 return -1;
   12139             :         }
   12140             :         {
   12141           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcStructureVersion));
   12142           0 :                 if (PyLong_Check(value)) {
   12143           0 :                         unsigned long long test_var;
   12144           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   12145           0 :                         if (PyErr_Occurred() != NULL) {
   12146           0 :                                 return -1;
   12147             :                         }
   12148           0 :                         if (test_var > uint_max) {
   12149           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   12150             :                                   PyLong_Type.tp_name, uint_max, test_var);
   12151           0 :                                 return -1;
   12152             :                         }
   12153           0 :                         object->dwRpcStructureVersion = test_var;
   12154             :                 } else {
   12155           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   12156             :                           PyLong_Type.tp_name);
   12157           0 :                         return -1;
   12158             :                 }
   12159             :         }
   12160           0 :         return 0;
   12161             : }
   12162             : 
   12163           0 : static PyObject *py_DNS_RPC_DP_ENUM_get_dwReserved0(PyObject *obj, void *closure)
   12164             : {
   12165           0 :         struct DNS_RPC_DP_ENUM *object = pytalloc_get_ptr(obj);
   12166           0 :         PyObject *py_dwReserved0;
   12167           0 :         py_dwReserved0 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved0));
   12168           0 :         return py_dwReserved0;
   12169             : }
   12170             : 
   12171           0 : static int py_DNS_RPC_DP_ENUM_set_dwReserved0(PyObject *py_obj, PyObject *value, void *closure)
   12172             : {
   12173           0 :         struct DNS_RPC_DP_ENUM *object = pytalloc_get_ptr(py_obj);
   12174           0 :         if (value == NULL) {
   12175           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved0");
   12176           0 :                 return -1;
   12177             :         }
   12178             :         {
   12179           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved0));
   12180           0 :                 if (PyLong_Check(value)) {
   12181           0 :                         unsigned long long test_var;
   12182           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   12183           0 :                         if (PyErr_Occurred() != NULL) {
   12184           0 :                                 return -1;
   12185             :                         }
   12186           0 :                         if (test_var > uint_max) {
   12187           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   12188             :                                   PyLong_Type.tp_name, uint_max, test_var);
   12189           0 :                                 return -1;
   12190             :                         }
   12191           0 :                         object->dwReserved0 = test_var;
   12192             :                 } else {
   12193           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   12194             :                           PyLong_Type.tp_name);
   12195           0 :                         return -1;
   12196             :                 }
   12197             :         }
   12198           0 :         return 0;
   12199             : }
   12200             : 
   12201           0 : static PyObject *py_DNS_RPC_DP_ENUM_get_pszDpFqdn(PyObject *obj, void *closure)
   12202             : {
   12203           0 :         struct DNS_RPC_DP_ENUM *object = pytalloc_get_ptr(obj);
   12204           0 :         PyObject *py_pszDpFqdn;
   12205           0 :         if (object->pszDpFqdn == NULL) {
   12206           0 :                 Py_RETURN_NONE;
   12207             :         }
   12208           0 :         if (object->pszDpFqdn == NULL) {
   12209           0 :                 py_pszDpFqdn = Py_None;
   12210           0 :                 Py_INCREF(py_pszDpFqdn);
   12211             :         } else {
   12212           0 :                 if (object->pszDpFqdn == NULL) {
   12213           0 :                         py_pszDpFqdn = Py_None;
   12214           0 :                         Py_INCREF(py_pszDpFqdn);
   12215             :                 } else {
   12216           0 :                         py_pszDpFqdn = PyUnicode_Decode(object->pszDpFqdn, strlen(object->pszDpFqdn), "utf-8", "ignore");
   12217             :                 }
   12218             :         }
   12219           0 :         return py_pszDpFqdn;
   12220             : }
   12221             : 
   12222           0 : static int py_DNS_RPC_DP_ENUM_set_pszDpFqdn(PyObject *py_obj, PyObject *value, void *closure)
   12223             : {
   12224           0 :         struct DNS_RPC_DP_ENUM *object = pytalloc_get_ptr(py_obj);
   12225           0 :         if (value == NULL) {
   12226           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszDpFqdn");
   12227           0 :                 return -1;
   12228             :         }
   12229           0 :         if (value == Py_None) {
   12230           0 :                 object->pszDpFqdn = NULL;
   12231             :         } else {
   12232           0 :                 object->pszDpFqdn = NULL;
   12233             :                 {
   12234           0 :                         const char *test_str;
   12235           0 :                         const char *talloc_str;
   12236           0 :                         PyObject *unicode = NULL;
   12237           0 :                         if (PyUnicode_Check(value)) {
   12238           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   12239           0 :                                 if (unicode == NULL) {
   12240           0 :                                         return -1;
   12241             :                                 }
   12242           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   12243           0 :                         } else if (PyBytes_Check(value)) {
   12244           0 :                                 test_str = PyBytes_AS_STRING(value);
   12245             :                         } else {
   12246           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   12247           0 :                                 return -1;
   12248             :                         }
   12249           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   12250           0 :                         if (unicode != NULL) {
   12251           0 :                                 Py_DECREF(unicode);
   12252             :                         }
   12253           0 :                         if (talloc_str == NULL) {
   12254           0 :                                 PyErr_NoMemory();
   12255           0 :                                 return -1;
   12256             :                         }
   12257           0 :                         object->pszDpFqdn = talloc_str;
   12258             :                 }
   12259             :         }
   12260           0 :         return 0;
   12261             : }
   12262             : 
   12263           0 : static PyObject *py_DNS_RPC_DP_ENUM_get_dwFlags(PyObject *obj, void *closure)
   12264             : {
   12265           0 :         struct DNS_RPC_DP_ENUM *object = pytalloc_get_ptr(obj);
   12266           0 :         PyObject *py_dwFlags;
   12267           0 :         py_dwFlags = PyLong_FromUnsignedLongLong((uint32_t)(object->dwFlags));
   12268           0 :         return py_dwFlags;
   12269             : }
   12270             : 
   12271           0 : static int py_DNS_RPC_DP_ENUM_set_dwFlags(PyObject *py_obj, PyObject *value, void *closure)
   12272             : {
   12273           0 :         struct DNS_RPC_DP_ENUM *object = pytalloc_get_ptr(py_obj);
   12274           0 :         if (value == NULL) {
   12275           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwFlags");
   12276           0 :                 return -1;
   12277             :         }
   12278             :         {
   12279           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwFlags));
   12280           0 :                 if (PyLong_Check(value)) {
   12281           0 :                         unsigned long long test_var;
   12282           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   12283           0 :                         if (PyErr_Occurred() != NULL) {
   12284           0 :                                 return -1;
   12285             :                         }
   12286           0 :                         if (test_var > uint_max) {
   12287           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   12288             :                                   PyLong_Type.tp_name, uint_max, test_var);
   12289           0 :                                 return -1;
   12290             :                         }
   12291           0 :                         object->dwFlags = test_var;
   12292             :                 } else {
   12293           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   12294             :                           PyLong_Type.tp_name);
   12295           0 :                         return -1;
   12296             :                 }
   12297             :         }
   12298           0 :         return 0;
   12299             : }
   12300             : 
   12301           0 : static PyObject *py_DNS_RPC_DP_ENUM_get_dwZoneCount(PyObject *obj, void *closure)
   12302             : {
   12303           0 :         struct DNS_RPC_DP_ENUM *object = pytalloc_get_ptr(obj);
   12304           0 :         PyObject *py_dwZoneCount;
   12305           0 :         py_dwZoneCount = PyLong_FromUnsignedLongLong((uint32_t)(object->dwZoneCount));
   12306           0 :         return py_dwZoneCount;
   12307             : }
   12308             : 
   12309           0 : static int py_DNS_RPC_DP_ENUM_set_dwZoneCount(PyObject *py_obj, PyObject *value, void *closure)
   12310             : {
   12311           0 :         struct DNS_RPC_DP_ENUM *object = pytalloc_get_ptr(py_obj);
   12312           0 :         if (value == NULL) {
   12313           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwZoneCount");
   12314           0 :                 return -1;
   12315             :         }
   12316             :         {
   12317           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwZoneCount));
   12318           0 :                 if (PyLong_Check(value)) {
   12319           0 :                         unsigned long long test_var;
   12320           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   12321           0 :                         if (PyErr_Occurred() != NULL) {
   12322           0 :                                 return -1;
   12323             :                         }
   12324           0 :                         if (test_var > uint_max) {
   12325           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   12326             :                                   PyLong_Type.tp_name, uint_max, test_var);
   12327           0 :                                 return -1;
   12328             :                         }
   12329           0 :                         object->dwZoneCount = test_var;
   12330             :                 } else {
   12331           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   12332             :                           PyLong_Type.tp_name);
   12333           0 :                         return -1;
   12334             :                 }
   12335             :         }
   12336           0 :         return 0;
   12337             : }
   12338             : 
   12339             : static PyGetSetDef py_DNS_RPC_DP_ENUM_getsetters[] = {
   12340             :         {
   12341             :                 .name = discard_const_p(char, "dwRpcStructureVersion"),
   12342             :                 .get = py_DNS_RPC_DP_ENUM_get_dwRpcStructureVersion,
   12343             :                 .set = py_DNS_RPC_DP_ENUM_set_dwRpcStructureVersion,
   12344             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   12345             :         },
   12346             :         {
   12347             :                 .name = discard_const_p(char, "dwReserved0"),
   12348             :                 .get = py_DNS_RPC_DP_ENUM_get_dwReserved0,
   12349             :                 .set = py_DNS_RPC_DP_ENUM_set_dwReserved0,
   12350             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   12351             :         },
   12352             :         {
   12353             :                 .name = discard_const_p(char, "pszDpFqdn"),
   12354             :                 .get = py_DNS_RPC_DP_ENUM_get_pszDpFqdn,
   12355             :                 .set = py_DNS_RPC_DP_ENUM_set_pszDpFqdn,
   12356             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   12357             :         },
   12358             :         {
   12359             :                 .name = discard_const_p(char, "dwFlags"),
   12360             :                 .get = py_DNS_RPC_DP_ENUM_get_dwFlags,
   12361             :                 .set = py_DNS_RPC_DP_ENUM_set_dwFlags,
   12362             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   12363             :         },
   12364             :         {
   12365             :                 .name = discard_const_p(char, "dwZoneCount"),
   12366             :                 .get = py_DNS_RPC_DP_ENUM_get_dwZoneCount,
   12367             :                 .set = py_DNS_RPC_DP_ENUM_set_dwZoneCount,
   12368             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   12369             :         },
   12370             :         { .name = NULL }
   12371             : };
   12372             : 
   12373           0 : static PyObject *py_DNS_RPC_DP_ENUM_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   12374             : {
   12375           0 :         return pytalloc_new(struct DNS_RPC_DP_ENUM, type);
   12376             : }
   12377             : 
   12378             : 
   12379             : static PyTypeObject DNS_RPC_DP_ENUM_Type = {
   12380             :         PyVarObject_HEAD_INIT(NULL, 0)
   12381             :         .tp_name = "dnsserver.DNS_RPC_DP_ENUM",
   12382             :         .tp_getset = py_DNS_RPC_DP_ENUM_getsetters,
   12383             :         .tp_methods = NULL,
   12384             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   12385             :         .tp_new = py_DNS_RPC_DP_ENUM_new,
   12386             : };
   12387             : 
   12388             : 
   12389           0 : static PyObject *py_DNS_RPC_DP_LIST_get_dwRpcStructureVersion(PyObject *obj, void *closure)
   12390             : {
   12391           0 :         struct DNS_RPC_DP_LIST *object = pytalloc_get_ptr(obj);
   12392           0 :         PyObject *py_dwRpcStructureVersion;
   12393           0 :         py_dwRpcStructureVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcStructureVersion));
   12394           0 :         return py_dwRpcStructureVersion;
   12395             : }
   12396             : 
   12397           0 : static int py_DNS_RPC_DP_LIST_set_dwRpcStructureVersion(PyObject *py_obj, PyObject *value, void *closure)
   12398             : {
   12399           0 :         struct DNS_RPC_DP_LIST *object = pytalloc_get_ptr(py_obj);
   12400           0 :         if (value == NULL) {
   12401           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcStructureVersion");
   12402           0 :                 return -1;
   12403             :         }
   12404             :         {
   12405           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcStructureVersion));
   12406           0 :                 if (PyLong_Check(value)) {
   12407           0 :                         unsigned long long test_var;
   12408           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   12409           0 :                         if (PyErr_Occurred() != NULL) {
   12410           0 :                                 return -1;
   12411             :                         }
   12412           0 :                         if (test_var > uint_max) {
   12413           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   12414             :                                   PyLong_Type.tp_name, uint_max, test_var);
   12415           0 :                                 return -1;
   12416             :                         }
   12417           0 :                         object->dwRpcStructureVersion = test_var;
   12418             :                 } else {
   12419           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   12420             :                           PyLong_Type.tp_name);
   12421           0 :                         return -1;
   12422             :                 }
   12423             :         }
   12424           0 :         return 0;
   12425             : }
   12426             : 
   12427           0 : static PyObject *py_DNS_RPC_DP_LIST_get_dwReserved0(PyObject *obj, void *closure)
   12428             : {
   12429           0 :         struct DNS_RPC_DP_LIST *object = pytalloc_get_ptr(obj);
   12430           0 :         PyObject *py_dwReserved0;
   12431           0 :         py_dwReserved0 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved0));
   12432           0 :         return py_dwReserved0;
   12433             : }
   12434             : 
   12435           0 : static int py_DNS_RPC_DP_LIST_set_dwReserved0(PyObject *py_obj, PyObject *value, void *closure)
   12436             : {
   12437           0 :         struct DNS_RPC_DP_LIST *object = pytalloc_get_ptr(py_obj);
   12438           0 :         if (value == NULL) {
   12439           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved0");
   12440           0 :                 return -1;
   12441             :         }
   12442             :         {
   12443           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved0));
   12444           0 :                 if (PyLong_Check(value)) {
   12445           0 :                         unsigned long long test_var;
   12446           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   12447           0 :                         if (PyErr_Occurred() != NULL) {
   12448           0 :                                 return -1;
   12449             :                         }
   12450           0 :                         if (test_var > uint_max) {
   12451           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   12452             :                                   PyLong_Type.tp_name, uint_max, test_var);
   12453           0 :                                 return -1;
   12454             :                         }
   12455           0 :                         object->dwReserved0 = test_var;
   12456             :                 } else {
   12457           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   12458             :                           PyLong_Type.tp_name);
   12459           0 :                         return -1;
   12460             :                 }
   12461             :         }
   12462           0 :         return 0;
   12463             : }
   12464             : 
   12465           0 : static PyObject *py_DNS_RPC_DP_LIST_get_dwDpCount(PyObject *obj, void *closure)
   12466             : {
   12467           0 :         struct DNS_RPC_DP_LIST *object = pytalloc_get_ptr(obj);
   12468           0 :         PyObject *py_dwDpCount;
   12469           0 :         py_dwDpCount = PyLong_FromUnsignedLongLong((uint32_t)(object->dwDpCount));
   12470           0 :         return py_dwDpCount;
   12471             : }
   12472             : 
   12473           0 : static int py_DNS_RPC_DP_LIST_set_dwDpCount(PyObject *py_obj, PyObject *value, void *closure)
   12474             : {
   12475           0 :         struct DNS_RPC_DP_LIST *object = pytalloc_get_ptr(py_obj);
   12476           0 :         if (value == NULL) {
   12477           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwDpCount");
   12478           0 :                 return -1;
   12479             :         }
   12480             :         {
   12481           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwDpCount));
   12482           0 :                 if (PyLong_Check(value)) {
   12483           0 :                         unsigned long long test_var;
   12484           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   12485           0 :                         if (PyErr_Occurred() != NULL) {
   12486           0 :                                 return -1;
   12487             :                         }
   12488           0 :                         if (test_var > uint_max) {
   12489           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   12490             :                                   PyLong_Type.tp_name, uint_max, test_var);
   12491           0 :                                 return -1;
   12492             :                         }
   12493           0 :                         object->dwDpCount = test_var;
   12494             :                 } else {
   12495           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   12496             :                           PyLong_Type.tp_name);
   12497           0 :                         return -1;
   12498             :                 }
   12499             :         }
   12500           0 :         return 0;
   12501             : }
   12502             : 
   12503           0 : static PyObject *py_DNS_RPC_DP_LIST_get_DpArray(PyObject *obj, void *closure)
   12504             : {
   12505           0 :         struct DNS_RPC_DP_LIST *object = pytalloc_get_ptr(obj);
   12506           0 :         PyObject *py_DpArray;
   12507           0 :         py_DpArray = PyList_New(object->dwDpCount);
   12508           0 :         if (py_DpArray == NULL) {
   12509           0 :                 return NULL;
   12510             :         }
   12511             :         {
   12512             :                 int DpArray_cntr_0;
   12513           0 :                 for (DpArray_cntr_0 = 0; DpArray_cntr_0 < (object->dwDpCount); DpArray_cntr_0++) {
   12514           0 :                         PyObject *py_DpArray_0;
   12515           0 :                         if ((object->DpArray)[DpArray_cntr_0] == NULL) {
   12516           0 :                                 py_DpArray_0 = Py_None;
   12517           0 :                                 Py_INCREF(py_DpArray_0);
   12518             :                         } else {
   12519           0 :                                 py_DpArray_0 = pytalloc_reference_ex(&DNS_RPC_DP_ENUM_Type, (object->DpArray)[DpArray_cntr_0], (object->DpArray)[DpArray_cntr_0]);
   12520             :                         }
   12521           0 :                         PyList_SetItem(py_DpArray, DpArray_cntr_0, py_DpArray_0);
   12522             :                 }
   12523             :         }
   12524           0 :         return py_DpArray;
   12525             : }
   12526             : 
   12527           0 : static int py_DNS_RPC_DP_LIST_set_DpArray(PyObject *py_obj, PyObject *value, void *closure)
   12528             : {
   12529           0 :         struct DNS_RPC_DP_LIST *object = pytalloc_get_ptr(py_obj);
   12530           0 :         if (value == NULL) {
   12531           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->DpArray");
   12532           0 :                 return -1;
   12533             :         }
   12534           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
   12535             :         {
   12536           0 :                 int DpArray_cntr_0;
   12537           0 :                 object->DpArray = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->DpArray, PyList_GET_SIZE(value));
   12538           0 :                 if (!object->DpArray) { return -1; }
   12539           0 :                 talloc_set_name_const(object->DpArray, "ARRAY: object->DpArray");
   12540           0 :                 for (DpArray_cntr_0 = 0; DpArray_cntr_0 < PyList_GET_SIZE(value); DpArray_cntr_0++) {
   12541           0 :                         if (PyList_GET_ITEM(value, DpArray_cntr_0) == NULL) {
   12542           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->DpArray)[DpArray_cntr_0]");
   12543           0 :                                 return -1;
   12544             :                         }
   12545           0 :                         if (PyList_GET_ITEM(value, DpArray_cntr_0) == Py_None) {
   12546           0 :                                 (object->DpArray)[DpArray_cntr_0] = NULL;
   12547             :                         } else {
   12548           0 :                                 (object->DpArray)[DpArray_cntr_0] = NULL;
   12549           0 :                                 PY_CHECK_TYPE(&DNS_RPC_DP_ENUM_Type, PyList_GET_ITEM(value, DpArray_cntr_0), return -1;);
   12550           0 :                                 if (talloc_reference(object->DpArray, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, DpArray_cntr_0))) == NULL) {
   12551           0 :                                         PyErr_NoMemory();
   12552           0 :                                         return -1;
   12553             :                                 }
   12554           0 :                                 (object->DpArray)[DpArray_cntr_0] = (struct DNS_RPC_DP_ENUM *)pytalloc_get_ptr(PyList_GET_ITEM(value, DpArray_cntr_0));
   12555             :                         }
   12556             :                 }
   12557             :         }
   12558           0 :         return 0;
   12559             : }
   12560             : 
   12561             : static PyGetSetDef py_DNS_RPC_DP_LIST_getsetters[] = {
   12562             :         {
   12563             :                 .name = discard_const_p(char, "dwRpcStructureVersion"),
   12564             :                 .get = py_DNS_RPC_DP_LIST_get_dwRpcStructureVersion,
   12565             :                 .set = py_DNS_RPC_DP_LIST_set_dwRpcStructureVersion,
   12566             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   12567             :         },
   12568             :         {
   12569             :                 .name = discard_const_p(char, "dwReserved0"),
   12570             :                 .get = py_DNS_RPC_DP_LIST_get_dwReserved0,
   12571             :                 .set = py_DNS_RPC_DP_LIST_set_dwReserved0,
   12572             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   12573             :         },
   12574             :         {
   12575             :                 .name = discard_const_p(char, "dwDpCount"),
   12576             :                 .get = py_DNS_RPC_DP_LIST_get_dwDpCount,
   12577             :                 .set = py_DNS_RPC_DP_LIST_set_dwDpCount,
   12578             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   12579             :         },
   12580             :         {
   12581             :                 .name = discard_const_p(char, "DpArray"),
   12582             :                 .get = py_DNS_RPC_DP_LIST_get_DpArray,
   12583             :                 .set = py_DNS_RPC_DP_LIST_set_DpArray,
   12584             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_DP_ENUM")
   12585             :         },
   12586             :         { .name = NULL }
   12587             : };
   12588             : 
   12589           0 : static PyObject *py_DNS_RPC_DP_LIST_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   12590             : {
   12591           0 :         return pytalloc_new(struct DNS_RPC_DP_LIST, type);
   12592             : }
   12593             : 
   12594             : 
   12595             : static PyTypeObject DNS_RPC_DP_LIST_Type = {
   12596             :         PyVarObject_HEAD_INIT(NULL, 0)
   12597             :         .tp_name = "dnsserver.DNS_RPC_DP_LIST",
   12598             :         .tp_getset = py_DNS_RPC_DP_LIST_getsetters,
   12599             :         .tp_methods = NULL,
   12600             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   12601             :         .tp_new = py_DNS_RPC_DP_LIST_new,
   12602             : };
   12603             : 
   12604             : 
   12605           0 : static PyObject *py_DNS_RPC_ENLIST_DP_get_dwRpcStructureVersion(PyObject *obj, void *closure)
   12606             : {
   12607           0 :         struct DNS_RPC_ENLIST_DP *object = pytalloc_get_ptr(obj);
   12608           0 :         PyObject *py_dwRpcStructureVersion;
   12609           0 :         py_dwRpcStructureVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcStructureVersion));
   12610           0 :         return py_dwRpcStructureVersion;
   12611             : }
   12612             : 
   12613           0 : static int py_DNS_RPC_ENLIST_DP_set_dwRpcStructureVersion(PyObject *py_obj, PyObject *value, void *closure)
   12614             : {
   12615           0 :         struct DNS_RPC_ENLIST_DP *object = pytalloc_get_ptr(py_obj);
   12616           0 :         if (value == NULL) {
   12617           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcStructureVersion");
   12618           0 :                 return -1;
   12619             :         }
   12620             :         {
   12621           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcStructureVersion));
   12622           0 :                 if (PyLong_Check(value)) {
   12623           0 :                         unsigned long long test_var;
   12624           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   12625           0 :                         if (PyErr_Occurred() != NULL) {
   12626           0 :                                 return -1;
   12627             :                         }
   12628           0 :                         if (test_var > uint_max) {
   12629           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   12630             :                                   PyLong_Type.tp_name, uint_max, test_var);
   12631           0 :                                 return -1;
   12632             :                         }
   12633           0 :                         object->dwRpcStructureVersion = test_var;
   12634             :                 } else {
   12635           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   12636             :                           PyLong_Type.tp_name);
   12637           0 :                         return -1;
   12638             :                 }
   12639             :         }
   12640           0 :         return 0;
   12641             : }
   12642             : 
   12643           0 : static PyObject *py_DNS_RPC_ENLIST_DP_get_dwReserved0(PyObject *obj, void *closure)
   12644             : {
   12645           0 :         struct DNS_RPC_ENLIST_DP *object = pytalloc_get_ptr(obj);
   12646           0 :         PyObject *py_dwReserved0;
   12647           0 :         py_dwReserved0 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved0));
   12648           0 :         return py_dwReserved0;
   12649             : }
   12650             : 
   12651           0 : static int py_DNS_RPC_ENLIST_DP_set_dwReserved0(PyObject *py_obj, PyObject *value, void *closure)
   12652             : {
   12653           0 :         struct DNS_RPC_ENLIST_DP *object = pytalloc_get_ptr(py_obj);
   12654           0 :         if (value == NULL) {
   12655           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved0");
   12656           0 :                 return -1;
   12657             :         }
   12658             :         {
   12659           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved0));
   12660           0 :                 if (PyLong_Check(value)) {
   12661           0 :                         unsigned long long test_var;
   12662           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   12663           0 :                         if (PyErr_Occurred() != NULL) {
   12664           0 :                                 return -1;
   12665             :                         }
   12666           0 :                         if (test_var > uint_max) {
   12667           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   12668             :                                   PyLong_Type.tp_name, uint_max, test_var);
   12669           0 :                                 return -1;
   12670             :                         }
   12671           0 :                         object->dwReserved0 = test_var;
   12672             :                 } else {
   12673           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   12674             :                           PyLong_Type.tp_name);
   12675           0 :                         return -1;
   12676             :                 }
   12677             :         }
   12678           0 :         return 0;
   12679             : }
   12680             : 
   12681           0 : static PyObject *py_DNS_RPC_ENLIST_DP_get_pszDpFqdn(PyObject *obj, void *closure)
   12682             : {
   12683           0 :         struct DNS_RPC_ENLIST_DP *object = pytalloc_get_ptr(obj);
   12684           0 :         PyObject *py_pszDpFqdn;
   12685           0 :         if (object->pszDpFqdn == NULL) {
   12686           0 :                 Py_RETURN_NONE;
   12687             :         }
   12688           0 :         if (object->pszDpFqdn == NULL) {
   12689           0 :                 py_pszDpFqdn = Py_None;
   12690           0 :                 Py_INCREF(py_pszDpFqdn);
   12691             :         } else {
   12692           0 :                 if (object->pszDpFqdn == NULL) {
   12693           0 :                         py_pszDpFqdn = Py_None;
   12694           0 :                         Py_INCREF(py_pszDpFqdn);
   12695             :                 } else {
   12696           0 :                         py_pszDpFqdn = PyUnicode_Decode(object->pszDpFqdn, strlen(object->pszDpFqdn), "utf-8", "ignore");
   12697             :                 }
   12698             :         }
   12699           0 :         return py_pszDpFqdn;
   12700             : }
   12701             : 
   12702           0 : static int py_DNS_RPC_ENLIST_DP_set_pszDpFqdn(PyObject *py_obj, PyObject *value, void *closure)
   12703             : {
   12704           0 :         struct DNS_RPC_ENLIST_DP *object = pytalloc_get_ptr(py_obj);
   12705           0 :         if (value == NULL) {
   12706           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszDpFqdn");
   12707           0 :                 return -1;
   12708             :         }
   12709           0 :         if (value == Py_None) {
   12710           0 :                 object->pszDpFqdn = NULL;
   12711             :         } else {
   12712           0 :                 object->pszDpFqdn = NULL;
   12713             :                 {
   12714           0 :                         const char *test_str;
   12715           0 :                         const char *talloc_str;
   12716           0 :                         PyObject *unicode = NULL;
   12717           0 :                         if (PyUnicode_Check(value)) {
   12718           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   12719           0 :                                 if (unicode == NULL) {
   12720           0 :                                         return -1;
   12721             :                                 }
   12722           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   12723           0 :                         } else if (PyBytes_Check(value)) {
   12724           0 :                                 test_str = PyBytes_AS_STRING(value);
   12725             :                         } else {
   12726           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   12727           0 :                                 return -1;
   12728             :                         }
   12729           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   12730           0 :                         if (unicode != NULL) {
   12731           0 :                                 Py_DECREF(unicode);
   12732             :                         }
   12733           0 :                         if (talloc_str == NULL) {
   12734           0 :                                 PyErr_NoMemory();
   12735           0 :                                 return -1;
   12736             :                         }
   12737           0 :                         object->pszDpFqdn = talloc_str;
   12738             :                 }
   12739             :         }
   12740           0 :         return 0;
   12741             : }
   12742             : 
   12743           0 : static PyObject *py_DNS_RPC_ENLIST_DP_get_dwOperation(PyObject *obj, void *closure)
   12744             : {
   12745           0 :         struct DNS_RPC_ENLIST_DP *object = pytalloc_get_ptr(obj);
   12746           0 :         PyObject *py_dwOperation;
   12747           0 :         py_dwOperation = PyLong_FromUnsignedLongLong((uint32_t)(object->dwOperation));
   12748           0 :         return py_dwOperation;
   12749             : }
   12750             : 
   12751           0 : static int py_DNS_RPC_ENLIST_DP_set_dwOperation(PyObject *py_obj, PyObject *value, void *closure)
   12752             : {
   12753           0 :         struct DNS_RPC_ENLIST_DP *object = pytalloc_get_ptr(py_obj);
   12754           0 :         if (value == NULL) {
   12755           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwOperation");
   12756           0 :                 return -1;
   12757             :         }
   12758             :         {
   12759           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwOperation));
   12760           0 :                 if (PyLong_Check(value)) {
   12761           0 :                         unsigned long long test_var;
   12762           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   12763           0 :                         if (PyErr_Occurred() != NULL) {
   12764           0 :                                 return -1;
   12765             :                         }
   12766           0 :                         if (test_var > uint_max) {
   12767           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   12768             :                                   PyLong_Type.tp_name, uint_max, test_var);
   12769           0 :                                 return -1;
   12770             :                         }
   12771           0 :                         object->dwOperation = test_var;
   12772             :                 } else {
   12773           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   12774             :                           PyLong_Type.tp_name);
   12775           0 :                         return -1;
   12776             :                 }
   12777             :         }
   12778           0 :         return 0;
   12779             : }
   12780             : 
   12781             : static PyGetSetDef py_DNS_RPC_ENLIST_DP_getsetters[] = {
   12782             :         {
   12783             :                 .name = discard_const_p(char, "dwRpcStructureVersion"),
   12784             :                 .get = py_DNS_RPC_ENLIST_DP_get_dwRpcStructureVersion,
   12785             :                 .set = py_DNS_RPC_ENLIST_DP_set_dwRpcStructureVersion,
   12786             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   12787             :         },
   12788             :         {
   12789             :                 .name = discard_const_p(char, "dwReserved0"),
   12790             :                 .get = py_DNS_RPC_ENLIST_DP_get_dwReserved0,
   12791             :                 .set = py_DNS_RPC_ENLIST_DP_set_dwReserved0,
   12792             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   12793             :         },
   12794             :         {
   12795             :                 .name = discard_const_p(char, "pszDpFqdn"),
   12796             :                 .get = py_DNS_RPC_ENLIST_DP_get_pszDpFqdn,
   12797             :                 .set = py_DNS_RPC_ENLIST_DP_set_pszDpFqdn,
   12798             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   12799             :         },
   12800             :         {
   12801             :                 .name = discard_const_p(char, "dwOperation"),
   12802             :                 .get = py_DNS_RPC_ENLIST_DP_get_dwOperation,
   12803             :                 .set = py_DNS_RPC_ENLIST_DP_set_dwOperation,
   12804             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   12805             :         },
   12806             :         { .name = NULL }
   12807             : };
   12808             : 
   12809           0 : static PyObject *py_DNS_RPC_ENLIST_DP_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   12810             : {
   12811           0 :         return pytalloc_new(struct DNS_RPC_ENLIST_DP, type);
   12812             : }
   12813             : 
   12814             : 
   12815             : static PyTypeObject DNS_RPC_ENLIST_DP_Type = {
   12816             :         PyVarObject_HEAD_INIT(NULL, 0)
   12817             :         .tp_name = "dnsserver.DNS_RPC_ENLIST_DP",
   12818             :         .tp_getset = py_DNS_RPC_ENLIST_DP_getsetters,
   12819             :         .tp_methods = NULL,
   12820             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   12821             :         .tp_new = py_DNS_RPC_ENLIST_DP_new,
   12822             : };
   12823             : 
   12824             : 
   12825           0 : static PyObject *py_DNS_RPC_ZONE_CHANGE_DP_get_dwRpcStructureVersion(PyObject *obj, void *closure)
   12826             : {
   12827           0 :         struct DNS_RPC_ZONE_CHANGE_DP *object = pytalloc_get_ptr(obj);
   12828           0 :         PyObject *py_dwRpcStructureVersion;
   12829           0 :         py_dwRpcStructureVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcStructureVersion));
   12830           0 :         return py_dwRpcStructureVersion;
   12831             : }
   12832             : 
   12833           0 : static int py_DNS_RPC_ZONE_CHANGE_DP_set_dwRpcStructureVersion(PyObject *py_obj, PyObject *value, void *closure)
   12834             : {
   12835           0 :         struct DNS_RPC_ZONE_CHANGE_DP *object = pytalloc_get_ptr(py_obj);
   12836           0 :         if (value == NULL) {
   12837           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcStructureVersion");
   12838           0 :                 return -1;
   12839             :         }
   12840             :         {
   12841           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcStructureVersion));
   12842           0 :                 if (PyLong_Check(value)) {
   12843           0 :                         unsigned long long test_var;
   12844           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   12845           0 :                         if (PyErr_Occurred() != NULL) {
   12846           0 :                                 return -1;
   12847             :                         }
   12848           0 :                         if (test_var > uint_max) {
   12849           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   12850             :                                   PyLong_Type.tp_name, uint_max, test_var);
   12851           0 :                                 return -1;
   12852             :                         }
   12853           0 :                         object->dwRpcStructureVersion = test_var;
   12854             :                 } else {
   12855           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   12856             :                           PyLong_Type.tp_name);
   12857           0 :                         return -1;
   12858             :                 }
   12859             :         }
   12860           0 :         return 0;
   12861             : }
   12862             : 
   12863           0 : static PyObject *py_DNS_RPC_ZONE_CHANGE_DP_get_dwReserved0(PyObject *obj, void *closure)
   12864             : {
   12865           0 :         struct DNS_RPC_ZONE_CHANGE_DP *object = pytalloc_get_ptr(obj);
   12866           0 :         PyObject *py_dwReserved0;
   12867           0 :         py_dwReserved0 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved0));
   12868           0 :         return py_dwReserved0;
   12869             : }
   12870             : 
   12871           0 : static int py_DNS_RPC_ZONE_CHANGE_DP_set_dwReserved0(PyObject *py_obj, PyObject *value, void *closure)
   12872             : {
   12873           0 :         struct DNS_RPC_ZONE_CHANGE_DP *object = pytalloc_get_ptr(py_obj);
   12874           0 :         if (value == NULL) {
   12875           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved0");
   12876           0 :                 return -1;
   12877             :         }
   12878             :         {
   12879           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved0));
   12880           0 :                 if (PyLong_Check(value)) {
   12881           0 :                         unsigned long long test_var;
   12882           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   12883           0 :                         if (PyErr_Occurred() != NULL) {
   12884           0 :                                 return -1;
   12885             :                         }
   12886           0 :                         if (test_var > uint_max) {
   12887           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   12888             :                                   PyLong_Type.tp_name, uint_max, test_var);
   12889           0 :                                 return -1;
   12890             :                         }
   12891           0 :                         object->dwReserved0 = test_var;
   12892             :                 } else {
   12893           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   12894             :                           PyLong_Type.tp_name);
   12895           0 :                         return -1;
   12896             :                 }
   12897             :         }
   12898           0 :         return 0;
   12899             : }
   12900             : 
   12901           0 : static PyObject *py_DNS_RPC_ZONE_CHANGE_DP_get_pszDestPartition(PyObject *obj, void *closure)
   12902             : {
   12903           0 :         struct DNS_RPC_ZONE_CHANGE_DP *object = pytalloc_get_ptr(obj);
   12904           0 :         PyObject *py_pszDestPartition;
   12905           0 :         if (object->pszDestPartition == NULL) {
   12906           0 :                 Py_RETURN_NONE;
   12907             :         }
   12908           0 :         if (object->pszDestPartition == NULL) {
   12909           0 :                 py_pszDestPartition = Py_None;
   12910           0 :                 Py_INCREF(py_pszDestPartition);
   12911             :         } else {
   12912           0 :                 if (object->pszDestPartition == NULL) {
   12913           0 :                         py_pszDestPartition = Py_None;
   12914           0 :                         Py_INCREF(py_pszDestPartition);
   12915             :                 } else {
   12916           0 :                         py_pszDestPartition = PyUnicode_Decode(object->pszDestPartition, strlen(object->pszDestPartition), "utf-8", "ignore");
   12917             :                 }
   12918             :         }
   12919           0 :         return py_pszDestPartition;
   12920             : }
   12921             : 
   12922           0 : static int py_DNS_RPC_ZONE_CHANGE_DP_set_pszDestPartition(PyObject *py_obj, PyObject *value, void *closure)
   12923             : {
   12924           0 :         struct DNS_RPC_ZONE_CHANGE_DP *object = pytalloc_get_ptr(py_obj);
   12925           0 :         if (value == NULL) {
   12926           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszDestPartition");
   12927           0 :                 return -1;
   12928             :         }
   12929           0 :         if (value == Py_None) {
   12930           0 :                 object->pszDestPartition = NULL;
   12931             :         } else {
   12932           0 :                 object->pszDestPartition = NULL;
   12933             :                 {
   12934           0 :                         const char *test_str;
   12935           0 :                         const char *talloc_str;
   12936           0 :                         PyObject *unicode = NULL;
   12937           0 :                         if (PyUnicode_Check(value)) {
   12938           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   12939           0 :                                 if (unicode == NULL) {
   12940           0 :                                         return -1;
   12941             :                                 }
   12942           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   12943           0 :                         } else if (PyBytes_Check(value)) {
   12944           0 :                                 test_str = PyBytes_AS_STRING(value);
   12945             :                         } else {
   12946           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   12947           0 :                                 return -1;
   12948             :                         }
   12949           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   12950           0 :                         if (unicode != NULL) {
   12951           0 :                                 Py_DECREF(unicode);
   12952             :                         }
   12953           0 :                         if (talloc_str == NULL) {
   12954           0 :                                 PyErr_NoMemory();
   12955           0 :                                 return -1;
   12956             :                         }
   12957           0 :                         object->pszDestPartition = talloc_str;
   12958             :                 }
   12959             :         }
   12960           0 :         return 0;
   12961             : }
   12962             : 
   12963             : static PyGetSetDef py_DNS_RPC_ZONE_CHANGE_DP_getsetters[] = {
   12964             :         {
   12965             :                 .name = discard_const_p(char, "dwRpcStructureVersion"),
   12966             :                 .get = py_DNS_RPC_ZONE_CHANGE_DP_get_dwRpcStructureVersion,
   12967             :                 .set = py_DNS_RPC_ZONE_CHANGE_DP_set_dwRpcStructureVersion,
   12968             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   12969             :         },
   12970             :         {
   12971             :                 .name = discard_const_p(char, "dwReserved0"),
   12972             :                 .get = py_DNS_RPC_ZONE_CHANGE_DP_get_dwReserved0,
   12973             :                 .set = py_DNS_RPC_ZONE_CHANGE_DP_set_dwReserved0,
   12974             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   12975             :         },
   12976             :         {
   12977             :                 .name = discard_const_p(char, "pszDestPartition"),
   12978             :                 .get = py_DNS_RPC_ZONE_CHANGE_DP_get_pszDestPartition,
   12979             :                 .set = py_DNS_RPC_ZONE_CHANGE_DP_set_pszDestPartition,
   12980             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   12981             :         },
   12982             :         { .name = NULL }
   12983             : };
   12984             : 
   12985           0 : static PyObject *py_DNS_RPC_ZONE_CHANGE_DP_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   12986             : {
   12987           0 :         return pytalloc_new(struct DNS_RPC_ZONE_CHANGE_DP, type);
   12988             : }
   12989             : 
   12990             : 
   12991             : static PyTypeObject DNS_RPC_ZONE_CHANGE_DP_Type = {
   12992             :         PyVarObject_HEAD_INIT(NULL, 0)
   12993             :         .tp_name = "dnsserver.DNS_RPC_ZONE_CHANGE_DP",
   12994             :         .tp_getset = py_DNS_RPC_ZONE_CHANGE_DP_getsetters,
   12995             :         .tp_methods = NULL,
   12996             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   12997             :         .tp_new = py_DNS_RPC_ZONE_CHANGE_DP_new,
   12998             : };
   12999             : 
   13000             : 
   13001           0 : static PyObject *py_DNS_RPC_ZONE_W2K_get_pszZoneName(PyObject *obj, void *closure)
   13002             : {
   13003           0 :         struct DNS_RPC_ZONE_W2K *object = pytalloc_get_ptr(obj);
   13004           0 :         PyObject *py_pszZoneName;
   13005           0 :         if (object->pszZoneName == NULL) {
   13006           0 :                 Py_RETURN_NONE;
   13007             :         }
   13008           0 :         if (object->pszZoneName == NULL) {
   13009           0 :                 py_pszZoneName = Py_None;
   13010           0 :                 Py_INCREF(py_pszZoneName);
   13011             :         } else {
   13012           0 :                 if (object->pszZoneName == NULL) {
   13013           0 :                         py_pszZoneName = Py_None;
   13014           0 :                         Py_INCREF(py_pszZoneName);
   13015             :                 } else {
   13016           0 :                         py_pszZoneName = PyUnicode_Decode(object->pszZoneName, strlen(object->pszZoneName), "utf-8", "ignore");
   13017             :                 }
   13018             :         }
   13019           0 :         return py_pszZoneName;
   13020             : }
   13021             : 
   13022           0 : static int py_DNS_RPC_ZONE_W2K_set_pszZoneName(PyObject *py_obj, PyObject *value, void *closure)
   13023             : {
   13024           0 :         struct DNS_RPC_ZONE_W2K *object = pytalloc_get_ptr(py_obj);
   13025           0 :         if (value == NULL) {
   13026           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszZoneName");
   13027           0 :                 return -1;
   13028             :         }
   13029           0 :         if (value == Py_None) {
   13030           0 :                 object->pszZoneName = NULL;
   13031             :         } else {
   13032           0 :                 object->pszZoneName = NULL;
   13033             :                 {
   13034           0 :                         const char *test_str;
   13035           0 :                         const char *talloc_str;
   13036           0 :                         PyObject *unicode = NULL;
   13037           0 :                         if (PyUnicode_Check(value)) {
   13038           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   13039           0 :                                 if (unicode == NULL) {
   13040           0 :                                         return -1;
   13041             :                                 }
   13042           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   13043           0 :                         } else if (PyBytes_Check(value)) {
   13044           0 :                                 test_str = PyBytes_AS_STRING(value);
   13045             :                         } else {
   13046           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   13047           0 :                                 return -1;
   13048             :                         }
   13049           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   13050           0 :                         if (unicode != NULL) {
   13051           0 :                                 Py_DECREF(unicode);
   13052             :                         }
   13053           0 :                         if (talloc_str == NULL) {
   13054           0 :                                 PyErr_NoMemory();
   13055           0 :                                 return -1;
   13056             :                         }
   13057           0 :                         object->pszZoneName = talloc_str;
   13058             :                 }
   13059             :         }
   13060           0 :         return 0;
   13061             : }
   13062             : 
   13063           0 : static PyObject *py_DNS_RPC_ZONE_W2K_get_Flags(PyObject *obj, void *closure)
   13064             : {
   13065           0 :         struct DNS_RPC_ZONE_W2K *object = pytalloc_get_ptr(obj);
   13066           0 :         PyObject *py_Flags;
   13067           0 :         py_Flags = PyLong_FromUnsignedLongLong((uint32_t)(object->Flags));
   13068           0 :         return py_Flags;
   13069             : }
   13070             : 
   13071           0 : static int py_DNS_RPC_ZONE_W2K_set_Flags(PyObject *py_obj, PyObject *value, void *closure)
   13072             : {
   13073           0 :         struct DNS_RPC_ZONE_W2K *object = pytalloc_get_ptr(py_obj);
   13074           0 :         if (value == NULL) {
   13075           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->Flags");
   13076           0 :                 return -1;
   13077             :         }
   13078             :         {
   13079           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->Flags));
   13080           0 :                 if (PyLong_Check(value)) {
   13081           0 :                         unsigned long long test_var;
   13082           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   13083           0 :                         if (PyErr_Occurred() != NULL) {
   13084           0 :                                 return -1;
   13085             :                         }
   13086           0 :                         if (test_var > uint_max) {
   13087           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   13088             :                                   PyLong_Type.tp_name, uint_max, test_var);
   13089           0 :                                 return -1;
   13090             :                         }
   13091           0 :                         object->Flags = test_var;
   13092             :                 } else {
   13093           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   13094             :                           PyLong_Type.tp_name);
   13095           0 :                         return -1;
   13096             :                 }
   13097             :         }
   13098           0 :         return 0;
   13099             : }
   13100             : 
   13101           0 : static PyObject *py_DNS_RPC_ZONE_W2K_get_ZoneType(PyObject *obj, void *closure)
   13102             : {
   13103           0 :         struct DNS_RPC_ZONE_W2K *object = pytalloc_get_ptr(obj);
   13104           0 :         PyObject *py_ZoneType;
   13105           0 :         py_ZoneType = PyLong_FromLong((uint16_t)(object->ZoneType));
   13106           0 :         return py_ZoneType;
   13107             : }
   13108             : 
   13109           0 : static int py_DNS_RPC_ZONE_W2K_set_ZoneType(PyObject *py_obj, PyObject *value, void *closure)
   13110             : {
   13111           0 :         struct DNS_RPC_ZONE_W2K *object = pytalloc_get_ptr(py_obj);
   13112           0 :         if (value == NULL) {
   13113           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->ZoneType");
   13114           0 :                 return -1;
   13115             :         }
   13116             :         {
   13117           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->ZoneType));
   13118           0 :                 if (PyLong_Check(value)) {
   13119           0 :                         unsigned long long test_var;
   13120           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   13121           0 :                         if (PyErr_Occurred() != NULL) {
   13122           0 :                                 return -1;
   13123             :                         }
   13124           0 :                         if (test_var > uint_max) {
   13125           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   13126             :                                   PyLong_Type.tp_name, uint_max, test_var);
   13127           0 :                                 return -1;
   13128             :                         }
   13129           0 :                         object->ZoneType = test_var;
   13130             :                 } else {
   13131           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   13132             :                           PyLong_Type.tp_name);
   13133           0 :                         return -1;
   13134             :                 }
   13135             :         }
   13136           0 :         return 0;
   13137             : }
   13138             : 
   13139           0 : static PyObject *py_DNS_RPC_ZONE_W2K_get_Version(PyObject *obj, void *closure)
   13140             : {
   13141           0 :         struct DNS_RPC_ZONE_W2K *object = pytalloc_get_ptr(obj);
   13142           0 :         PyObject *py_Version;
   13143           0 :         py_Version = PyLong_FromLong((uint16_t)(object->Version));
   13144           0 :         return py_Version;
   13145             : }
   13146             : 
   13147           0 : static int py_DNS_RPC_ZONE_W2K_set_Version(PyObject *py_obj, PyObject *value, void *closure)
   13148             : {
   13149           0 :         struct DNS_RPC_ZONE_W2K *object = pytalloc_get_ptr(py_obj);
   13150           0 :         if (value == NULL) {
   13151           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->Version");
   13152           0 :                 return -1;
   13153             :         }
   13154             :         {
   13155           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->Version));
   13156           0 :                 if (PyLong_Check(value)) {
   13157           0 :                         unsigned long long test_var;
   13158           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   13159           0 :                         if (PyErr_Occurred() != NULL) {
   13160           0 :                                 return -1;
   13161             :                         }
   13162           0 :                         if (test_var > uint_max) {
   13163           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   13164             :                                   PyLong_Type.tp_name, uint_max, test_var);
   13165           0 :                                 return -1;
   13166             :                         }
   13167           0 :                         object->Version = test_var;
   13168             :                 } else {
   13169           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   13170             :                           PyLong_Type.tp_name);
   13171           0 :                         return -1;
   13172             :                 }
   13173             :         }
   13174           0 :         return 0;
   13175             : }
   13176             : 
   13177             : static PyGetSetDef py_DNS_RPC_ZONE_W2K_getsetters[] = {
   13178             :         {
   13179             :                 .name = discard_const_p(char, "pszZoneName"),
   13180             :                 .get = py_DNS_RPC_ZONE_W2K_get_pszZoneName,
   13181             :                 .set = py_DNS_RPC_ZONE_W2K_set_pszZoneName,
   13182             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
   13183             :         },
   13184             :         {
   13185             :                 .name = discard_const_p(char, "Flags"),
   13186             :                 .get = py_DNS_RPC_ZONE_W2K_get_Flags,
   13187             :                 .set = py_DNS_RPC_ZONE_W2K_set_Flags,
   13188             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_ZONE_FLAGS")
   13189             :         },
   13190             :         {
   13191             :                 .name = discard_const_p(char, "ZoneType"),
   13192             :                 .get = py_DNS_RPC_ZONE_W2K_get_ZoneType,
   13193             :                 .set = py_DNS_RPC_ZONE_W2K_set_ZoneType,
   13194             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   13195             :         },
   13196             :         {
   13197             :                 .name = discard_const_p(char, "Version"),
   13198             :                 .get = py_DNS_RPC_ZONE_W2K_get_Version,
   13199             :                 .set = py_DNS_RPC_ZONE_W2K_set_Version,
   13200             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   13201             :         },
   13202             :         { .name = NULL }
   13203             : };
   13204             : 
   13205           0 : static PyObject *py_DNS_RPC_ZONE_W2K_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   13206             : {
   13207           0 :         return pytalloc_new(struct DNS_RPC_ZONE_W2K, type);
   13208             : }
   13209             : 
   13210             : 
   13211             : static PyTypeObject DNS_RPC_ZONE_W2K_Type = {
   13212             :         PyVarObject_HEAD_INIT(NULL, 0)
   13213             :         .tp_name = "dnsserver.DNS_RPC_ZONE_W2K",
   13214             :         .tp_getset = py_DNS_RPC_ZONE_W2K_getsetters,
   13215             :         .tp_methods = NULL,
   13216             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   13217             :         .tp_new = py_DNS_RPC_ZONE_W2K_new,
   13218             : };
   13219             : 
   13220             : 
   13221           0 : static PyObject *py_DNS_RPC_ZONE_DOTNET_get_dwRpcStructureVersion(PyObject *obj, void *closure)
   13222             : {
   13223           0 :         struct DNS_RPC_ZONE_DOTNET *object = pytalloc_get_ptr(obj);
   13224           0 :         PyObject *py_dwRpcStructureVersion;
   13225           0 :         py_dwRpcStructureVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcStructureVersion));
   13226           0 :         return py_dwRpcStructureVersion;
   13227             : }
   13228             : 
   13229           0 : static int py_DNS_RPC_ZONE_DOTNET_set_dwRpcStructureVersion(PyObject *py_obj, PyObject *value, void *closure)
   13230             : {
   13231           0 :         struct DNS_RPC_ZONE_DOTNET *object = pytalloc_get_ptr(py_obj);
   13232           0 :         if (value == NULL) {
   13233           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcStructureVersion");
   13234           0 :                 return -1;
   13235             :         }
   13236             :         {
   13237           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcStructureVersion));
   13238           0 :                 if (PyLong_Check(value)) {
   13239           0 :                         unsigned long long test_var;
   13240           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   13241           0 :                         if (PyErr_Occurred() != NULL) {
   13242           0 :                                 return -1;
   13243             :                         }
   13244           0 :                         if (test_var > uint_max) {
   13245           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   13246             :                                   PyLong_Type.tp_name, uint_max, test_var);
   13247           0 :                                 return -1;
   13248             :                         }
   13249           0 :                         object->dwRpcStructureVersion = test_var;
   13250             :                 } else {
   13251           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   13252             :                           PyLong_Type.tp_name);
   13253           0 :                         return -1;
   13254             :                 }
   13255             :         }
   13256           0 :         return 0;
   13257             : }
   13258             : 
   13259           0 : static PyObject *py_DNS_RPC_ZONE_DOTNET_get_dwReserved0(PyObject *obj, void *closure)
   13260             : {
   13261           0 :         struct DNS_RPC_ZONE_DOTNET *object = pytalloc_get_ptr(obj);
   13262           0 :         PyObject *py_dwReserved0;
   13263           0 :         py_dwReserved0 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved0));
   13264           0 :         return py_dwReserved0;
   13265             : }
   13266             : 
   13267           0 : static int py_DNS_RPC_ZONE_DOTNET_set_dwReserved0(PyObject *py_obj, PyObject *value, void *closure)
   13268             : {
   13269           0 :         struct DNS_RPC_ZONE_DOTNET *object = pytalloc_get_ptr(py_obj);
   13270           0 :         if (value == NULL) {
   13271           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved0");
   13272           0 :                 return -1;
   13273             :         }
   13274             :         {
   13275           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved0));
   13276           0 :                 if (PyLong_Check(value)) {
   13277           0 :                         unsigned long long test_var;
   13278           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   13279           0 :                         if (PyErr_Occurred() != NULL) {
   13280           0 :                                 return -1;
   13281             :                         }
   13282           0 :                         if (test_var > uint_max) {
   13283           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   13284             :                                   PyLong_Type.tp_name, uint_max, test_var);
   13285           0 :                                 return -1;
   13286             :                         }
   13287           0 :                         object->dwReserved0 = test_var;
   13288             :                 } else {
   13289           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   13290             :                           PyLong_Type.tp_name);
   13291           0 :                         return -1;
   13292             :                 }
   13293             :         }
   13294           0 :         return 0;
   13295             : }
   13296             : 
   13297          18 : static PyObject *py_DNS_RPC_ZONE_DOTNET_get_pszZoneName(PyObject *obj, void *closure)
   13298             : {
   13299          18 :         struct DNS_RPC_ZONE_DOTNET *object = pytalloc_get_ptr(obj);
   13300           0 :         PyObject *py_pszZoneName;
   13301          18 :         if (object->pszZoneName == NULL) {
   13302           0 :                 Py_RETURN_NONE;
   13303             :         }
   13304          18 :         if (object->pszZoneName == NULL) {
   13305           0 :                 py_pszZoneName = Py_None;
   13306           0 :                 Py_INCREF(py_pszZoneName);
   13307             :         } else {
   13308          18 :                 if (object->pszZoneName == NULL) {
   13309           0 :                         py_pszZoneName = Py_None;
   13310           0 :                         Py_INCREF(py_pszZoneName);
   13311             :                 } else {
   13312          18 :                         py_pszZoneName = PyUnicode_Decode(object->pszZoneName, strlen(object->pszZoneName), "utf-8", "ignore");
   13313             :                 }
   13314             :         }
   13315          18 :         return py_pszZoneName;
   13316             : }
   13317             : 
   13318           0 : static int py_DNS_RPC_ZONE_DOTNET_set_pszZoneName(PyObject *py_obj, PyObject *value, void *closure)
   13319             : {
   13320           0 :         struct DNS_RPC_ZONE_DOTNET *object = pytalloc_get_ptr(py_obj);
   13321           0 :         if (value == NULL) {
   13322           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszZoneName");
   13323           0 :                 return -1;
   13324             :         }
   13325           0 :         if (value == Py_None) {
   13326           0 :                 object->pszZoneName = NULL;
   13327             :         } else {
   13328           0 :                 object->pszZoneName = NULL;
   13329             :                 {
   13330           0 :                         const char *test_str;
   13331           0 :                         const char *talloc_str;
   13332           0 :                         PyObject *unicode = NULL;
   13333           0 :                         if (PyUnicode_Check(value)) {
   13334           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   13335           0 :                                 if (unicode == NULL) {
   13336           0 :                                         return -1;
   13337             :                                 }
   13338           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   13339           0 :                         } else if (PyBytes_Check(value)) {
   13340           0 :                                 test_str = PyBytes_AS_STRING(value);
   13341             :                         } else {
   13342           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   13343           0 :                                 return -1;
   13344             :                         }
   13345           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   13346           0 :                         if (unicode != NULL) {
   13347           0 :                                 Py_DECREF(unicode);
   13348             :                         }
   13349           0 :                         if (talloc_str == NULL) {
   13350           0 :                                 PyErr_NoMemory();
   13351           0 :                                 return -1;
   13352             :                         }
   13353           0 :                         object->pszZoneName = talloc_str;
   13354             :                 }
   13355             :         }
   13356           0 :         return 0;
   13357             : }
   13358             : 
   13359           6 : static PyObject *py_DNS_RPC_ZONE_DOTNET_get_Flags(PyObject *obj, void *closure)
   13360             : {
   13361           6 :         struct DNS_RPC_ZONE_DOTNET *object = pytalloc_get_ptr(obj);
   13362           0 :         PyObject *py_Flags;
   13363           6 :         py_Flags = PyLong_FromUnsignedLongLong((uint32_t)(object->Flags));
   13364           6 :         return py_Flags;
   13365             : }
   13366             : 
   13367           0 : static int py_DNS_RPC_ZONE_DOTNET_set_Flags(PyObject *py_obj, PyObject *value, void *closure)
   13368             : {
   13369           0 :         struct DNS_RPC_ZONE_DOTNET *object = pytalloc_get_ptr(py_obj);
   13370           0 :         if (value == NULL) {
   13371           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->Flags");
   13372           0 :                 return -1;
   13373             :         }
   13374             :         {
   13375           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->Flags));
   13376           0 :                 if (PyLong_Check(value)) {
   13377           0 :                         unsigned long long test_var;
   13378           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   13379           0 :                         if (PyErr_Occurred() != NULL) {
   13380           0 :                                 return -1;
   13381             :                         }
   13382           0 :                         if (test_var > uint_max) {
   13383           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   13384             :                                   PyLong_Type.tp_name, uint_max, test_var);
   13385           0 :                                 return -1;
   13386             :                         }
   13387           0 :                         object->Flags = test_var;
   13388             :                 } else {
   13389           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   13390             :                           PyLong_Type.tp_name);
   13391           0 :                         return -1;
   13392             :                 }
   13393             :         }
   13394           0 :         return 0;
   13395             : }
   13396             : 
   13397           6 : static PyObject *py_DNS_RPC_ZONE_DOTNET_get_ZoneType(PyObject *obj, void *closure)
   13398             : {
   13399           6 :         struct DNS_RPC_ZONE_DOTNET *object = pytalloc_get_ptr(obj);
   13400           0 :         PyObject *py_ZoneType;
   13401           6 :         py_ZoneType = PyLong_FromLong((uint16_t)(object->ZoneType));
   13402           6 :         return py_ZoneType;
   13403             : }
   13404             : 
   13405           0 : static int py_DNS_RPC_ZONE_DOTNET_set_ZoneType(PyObject *py_obj, PyObject *value, void *closure)
   13406             : {
   13407           0 :         struct DNS_RPC_ZONE_DOTNET *object = pytalloc_get_ptr(py_obj);
   13408           0 :         if (value == NULL) {
   13409           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->ZoneType");
   13410           0 :                 return -1;
   13411             :         }
   13412             :         {
   13413           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->ZoneType));
   13414           0 :                 if (PyLong_Check(value)) {
   13415           0 :                         unsigned long long test_var;
   13416           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   13417           0 :                         if (PyErr_Occurred() != NULL) {
   13418           0 :                                 return -1;
   13419             :                         }
   13420           0 :                         if (test_var > uint_max) {
   13421           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   13422             :                                   PyLong_Type.tp_name, uint_max, test_var);
   13423           0 :                                 return -1;
   13424             :                         }
   13425           0 :                         object->ZoneType = test_var;
   13426             :                 } else {
   13427           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   13428             :                           PyLong_Type.tp_name);
   13429           0 :                         return -1;
   13430             :                 }
   13431             :         }
   13432           0 :         return 0;
   13433             : }
   13434             : 
   13435           6 : static PyObject *py_DNS_RPC_ZONE_DOTNET_get_Version(PyObject *obj, void *closure)
   13436             : {
   13437           6 :         struct DNS_RPC_ZONE_DOTNET *object = pytalloc_get_ptr(obj);
   13438           0 :         PyObject *py_Version;
   13439           6 :         py_Version = PyLong_FromLong((uint16_t)(object->Version));
   13440           6 :         return py_Version;
   13441             : }
   13442             : 
   13443           0 : static int py_DNS_RPC_ZONE_DOTNET_set_Version(PyObject *py_obj, PyObject *value, void *closure)
   13444             : {
   13445           0 :         struct DNS_RPC_ZONE_DOTNET *object = pytalloc_get_ptr(py_obj);
   13446           0 :         if (value == NULL) {
   13447           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->Version");
   13448           0 :                 return -1;
   13449             :         }
   13450             :         {
   13451           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->Version));
   13452           0 :                 if (PyLong_Check(value)) {
   13453           0 :                         unsigned long long test_var;
   13454           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   13455           0 :                         if (PyErr_Occurred() != NULL) {
   13456           0 :                                 return -1;
   13457             :                         }
   13458           0 :                         if (test_var > uint_max) {
   13459           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   13460             :                                   PyLong_Type.tp_name, uint_max, test_var);
   13461           0 :                                 return -1;
   13462             :                         }
   13463           0 :                         object->Version = test_var;
   13464             :                 } else {
   13465           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   13466             :                           PyLong_Type.tp_name);
   13467           0 :                         return -1;
   13468             :                 }
   13469             :         }
   13470           0 :         return 0;
   13471             : }
   13472             : 
   13473           6 : static PyObject *py_DNS_RPC_ZONE_DOTNET_get_dwDpFlags(PyObject *obj, void *closure)
   13474             : {
   13475           6 :         struct DNS_RPC_ZONE_DOTNET *object = pytalloc_get_ptr(obj);
   13476           0 :         PyObject *py_dwDpFlags;
   13477           6 :         py_dwDpFlags = PyLong_FromUnsignedLongLong((uint32_t)(object->dwDpFlags));
   13478           6 :         return py_dwDpFlags;
   13479             : }
   13480             : 
   13481           0 : static int py_DNS_RPC_ZONE_DOTNET_set_dwDpFlags(PyObject *py_obj, PyObject *value, void *closure)
   13482             : {
   13483           0 :         struct DNS_RPC_ZONE_DOTNET *object = pytalloc_get_ptr(py_obj);
   13484           0 :         if (value == NULL) {
   13485           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwDpFlags");
   13486           0 :                 return -1;
   13487             :         }
   13488             :         {
   13489           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwDpFlags));
   13490           0 :                 if (PyLong_Check(value)) {
   13491           0 :                         unsigned long long test_var;
   13492           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   13493           0 :                         if (PyErr_Occurred() != NULL) {
   13494           0 :                                 return -1;
   13495             :                         }
   13496           0 :                         if (test_var > uint_max) {
   13497           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   13498             :                                   PyLong_Type.tp_name, uint_max, test_var);
   13499           0 :                                 return -1;
   13500             :                         }
   13501           0 :                         object->dwDpFlags = test_var;
   13502             :                 } else {
   13503           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   13504             :                           PyLong_Type.tp_name);
   13505           0 :                         return -1;
   13506             :                 }
   13507             :         }
   13508           0 :         return 0;
   13509             : }
   13510             : 
   13511           6 : static PyObject *py_DNS_RPC_ZONE_DOTNET_get_pszDpFqdn(PyObject *obj, void *closure)
   13512             : {
   13513           6 :         struct DNS_RPC_ZONE_DOTNET *object = pytalloc_get_ptr(obj);
   13514           0 :         PyObject *py_pszDpFqdn;
   13515           6 :         if (object->pszDpFqdn == NULL) {
   13516           0 :                 Py_RETURN_NONE;
   13517             :         }
   13518           6 :         if (object->pszDpFqdn == NULL) {
   13519           0 :                 py_pszDpFqdn = Py_None;
   13520           0 :                 Py_INCREF(py_pszDpFqdn);
   13521             :         } else {
   13522           6 :                 if (object->pszDpFqdn == NULL) {
   13523           0 :                         py_pszDpFqdn = Py_None;
   13524           0 :                         Py_INCREF(py_pszDpFqdn);
   13525             :                 } else {
   13526           6 :                         py_pszDpFqdn = PyUnicode_Decode(object->pszDpFqdn, strlen(object->pszDpFqdn), "utf-8", "ignore");
   13527             :                 }
   13528             :         }
   13529           6 :         return py_pszDpFqdn;
   13530             : }
   13531             : 
   13532           0 : static int py_DNS_RPC_ZONE_DOTNET_set_pszDpFqdn(PyObject *py_obj, PyObject *value, void *closure)
   13533             : {
   13534           0 :         struct DNS_RPC_ZONE_DOTNET *object = pytalloc_get_ptr(py_obj);
   13535           0 :         if (value == NULL) {
   13536           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszDpFqdn");
   13537           0 :                 return -1;
   13538             :         }
   13539           0 :         if (value == Py_None) {
   13540           0 :                 object->pszDpFqdn = NULL;
   13541             :         } else {
   13542           0 :                 object->pszDpFqdn = NULL;
   13543             :                 {
   13544           0 :                         const char *test_str;
   13545           0 :                         const char *talloc_str;
   13546           0 :                         PyObject *unicode = NULL;
   13547           0 :                         if (PyUnicode_Check(value)) {
   13548           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   13549           0 :                                 if (unicode == NULL) {
   13550           0 :                                         return -1;
   13551             :                                 }
   13552           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   13553           0 :                         } else if (PyBytes_Check(value)) {
   13554           0 :                                 test_str = PyBytes_AS_STRING(value);
   13555             :                         } else {
   13556           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   13557           0 :                                 return -1;
   13558             :                         }
   13559           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   13560           0 :                         if (unicode != NULL) {
   13561           0 :                                 Py_DECREF(unicode);
   13562             :                         }
   13563           0 :                         if (talloc_str == NULL) {
   13564           0 :                                 PyErr_NoMemory();
   13565           0 :                                 return -1;
   13566             :                         }
   13567           0 :                         object->pszDpFqdn = talloc_str;
   13568             :                 }
   13569             :         }
   13570           0 :         return 0;
   13571             : }
   13572             : 
   13573             : static PyGetSetDef py_DNS_RPC_ZONE_DOTNET_getsetters[] = {
   13574             :         {
   13575             :                 .name = discard_const_p(char, "dwRpcStructureVersion"),
   13576             :                 .get = py_DNS_RPC_ZONE_DOTNET_get_dwRpcStructureVersion,
   13577             :                 .set = py_DNS_RPC_ZONE_DOTNET_set_dwRpcStructureVersion,
   13578             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   13579             :         },
   13580             :         {
   13581             :                 .name = discard_const_p(char, "dwReserved0"),
   13582             :                 .get = py_DNS_RPC_ZONE_DOTNET_get_dwReserved0,
   13583             :                 .set = py_DNS_RPC_ZONE_DOTNET_set_dwReserved0,
   13584             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   13585             :         },
   13586             :         {
   13587             :                 .name = discard_const_p(char, "pszZoneName"),
   13588             :                 .get = py_DNS_RPC_ZONE_DOTNET_get_pszZoneName,
   13589             :                 .set = py_DNS_RPC_ZONE_DOTNET_set_pszZoneName,
   13590             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
   13591             :         },
   13592             :         {
   13593             :                 .name = discard_const_p(char, "Flags"),
   13594             :                 .get = py_DNS_RPC_ZONE_DOTNET_get_Flags,
   13595             :                 .set = py_DNS_RPC_ZONE_DOTNET_set_Flags,
   13596             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_ZONE_FLAGS")
   13597             :         },
   13598             :         {
   13599             :                 .name = discard_const_p(char, "ZoneType"),
   13600             :                 .get = py_DNS_RPC_ZONE_DOTNET_get_ZoneType,
   13601             :                 .set = py_DNS_RPC_ZONE_DOTNET_set_ZoneType,
   13602             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   13603             :         },
   13604             :         {
   13605             :                 .name = discard_const_p(char, "Version"),
   13606             :                 .get = py_DNS_RPC_ZONE_DOTNET_get_Version,
   13607             :                 .set = py_DNS_RPC_ZONE_DOTNET_set_Version,
   13608             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   13609             :         },
   13610             :         {
   13611             :                 .name = discard_const_p(char, "dwDpFlags"),
   13612             :                 .get = py_DNS_RPC_ZONE_DOTNET_get_dwDpFlags,
   13613             :                 .set = py_DNS_RPC_ZONE_DOTNET_set_dwDpFlags,
   13614             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_DP_FLAGS")
   13615             :         },
   13616             :         {
   13617             :                 .name = discard_const_p(char, "pszDpFqdn"),
   13618             :                 .get = py_DNS_RPC_ZONE_DOTNET_get_pszDpFqdn,
   13619             :                 .set = py_DNS_RPC_ZONE_DOTNET_set_pszDpFqdn,
   13620             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   13621             :         },
   13622             :         { .name = NULL }
   13623             : };
   13624             : 
   13625           0 : static PyObject *py_DNS_RPC_ZONE_DOTNET_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   13626             : {
   13627           0 :         return pytalloc_new(struct DNS_RPC_ZONE_DOTNET, type);
   13628             : }
   13629             : 
   13630             : 
   13631             : static PyTypeObject DNS_RPC_ZONE_DOTNET_Type = {
   13632             :         PyVarObject_HEAD_INIT(NULL, 0)
   13633             :         .tp_name = "dnsserver.DNS_RPC_ZONE_DOTNET",
   13634             :         .tp_getset = py_DNS_RPC_ZONE_DOTNET_getsetters,
   13635             :         .tp_methods = NULL,
   13636             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   13637             :         .tp_new = py_DNS_RPC_ZONE_DOTNET_new,
   13638             : };
   13639             : 
   13640             : 
   13641           0 : static PyObject *py_DNS_RPC_ZONE_LIST_W2K_get_dwZoneCount(PyObject *obj, void *closure)
   13642             : {
   13643           0 :         struct DNS_RPC_ZONE_LIST_W2K *object = pytalloc_get_ptr(obj);
   13644           0 :         PyObject *py_dwZoneCount;
   13645           0 :         py_dwZoneCount = PyLong_FromUnsignedLongLong((uint32_t)(object->dwZoneCount));
   13646           0 :         return py_dwZoneCount;
   13647             : }
   13648             : 
   13649           0 : static int py_DNS_RPC_ZONE_LIST_W2K_set_dwZoneCount(PyObject *py_obj, PyObject *value, void *closure)
   13650             : {
   13651           0 :         struct DNS_RPC_ZONE_LIST_W2K *object = pytalloc_get_ptr(py_obj);
   13652           0 :         if (value == NULL) {
   13653           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwZoneCount");
   13654           0 :                 return -1;
   13655             :         }
   13656             :         {
   13657           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwZoneCount));
   13658           0 :                 if (PyLong_Check(value)) {
   13659           0 :                         unsigned long long test_var;
   13660           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   13661           0 :                         if (PyErr_Occurred() != NULL) {
   13662           0 :                                 return -1;
   13663             :                         }
   13664           0 :                         if (test_var > uint_max) {
   13665           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   13666             :                                   PyLong_Type.tp_name, uint_max, test_var);
   13667           0 :                                 return -1;
   13668             :                         }
   13669           0 :                         object->dwZoneCount = test_var;
   13670             :                 } else {
   13671           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   13672             :                           PyLong_Type.tp_name);
   13673           0 :                         return -1;
   13674             :                 }
   13675             :         }
   13676           0 :         return 0;
   13677             : }
   13678             : 
   13679           0 : static PyObject *py_DNS_RPC_ZONE_LIST_W2K_get_ZoneArray(PyObject *obj, void *closure)
   13680             : {
   13681           0 :         struct DNS_RPC_ZONE_LIST_W2K *object = pytalloc_get_ptr(obj);
   13682           0 :         PyObject *py_ZoneArray;
   13683           0 :         py_ZoneArray = PyList_New(object->dwZoneCount);
   13684           0 :         if (py_ZoneArray == NULL) {
   13685           0 :                 return NULL;
   13686             :         }
   13687             :         {
   13688             :                 int ZoneArray_cntr_0;
   13689           0 :                 for (ZoneArray_cntr_0 = 0; ZoneArray_cntr_0 < (object->dwZoneCount); ZoneArray_cntr_0++) {
   13690           0 :                         PyObject *py_ZoneArray_0;
   13691           0 :                         if ((object->ZoneArray)[ZoneArray_cntr_0] == NULL) {
   13692           0 :                                 py_ZoneArray_0 = Py_None;
   13693           0 :                                 Py_INCREF(py_ZoneArray_0);
   13694             :                         } else {
   13695           0 :                                 py_ZoneArray_0 = pytalloc_reference_ex(&DNS_RPC_ZONE_W2K_Type, (object->ZoneArray)[ZoneArray_cntr_0], (object->ZoneArray)[ZoneArray_cntr_0]);
   13696             :                         }
   13697           0 :                         PyList_SetItem(py_ZoneArray, ZoneArray_cntr_0, py_ZoneArray_0);
   13698             :                 }
   13699             :         }
   13700           0 :         return py_ZoneArray;
   13701             : }
   13702             : 
   13703           0 : static int py_DNS_RPC_ZONE_LIST_W2K_set_ZoneArray(PyObject *py_obj, PyObject *value, void *closure)
   13704             : {
   13705           0 :         struct DNS_RPC_ZONE_LIST_W2K *object = pytalloc_get_ptr(py_obj);
   13706           0 :         if (value == NULL) {
   13707           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->ZoneArray");
   13708           0 :                 return -1;
   13709             :         }
   13710           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
   13711             :         {
   13712           0 :                 int ZoneArray_cntr_0;
   13713           0 :                 object->ZoneArray = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->ZoneArray, PyList_GET_SIZE(value));
   13714           0 :                 if (!object->ZoneArray) { return -1; }
   13715           0 :                 talloc_set_name_const(object->ZoneArray, "ARRAY: object->ZoneArray");
   13716           0 :                 for (ZoneArray_cntr_0 = 0; ZoneArray_cntr_0 < PyList_GET_SIZE(value); ZoneArray_cntr_0++) {
   13717           0 :                         if (PyList_GET_ITEM(value, ZoneArray_cntr_0) == NULL) {
   13718           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->ZoneArray)[ZoneArray_cntr_0]");
   13719           0 :                                 return -1;
   13720             :                         }
   13721           0 :                         if (PyList_GET_ITEM(value, ZoneArray_cntr_0) == Py_None) {
   13722           0 :                                 (object->ZoneArray)[ZoneArray_cntr_0] = NULL;
   13723             :                         } else {
   13724           0 :                                 (object->ZoneArray)[ZoneArray_cntr_0] = NULL;
   13725           0 :                                 PY_CHECK_TYPE(&DNS_RPC_ZONE_W2K_Type, PyList_GET_ITEM(value, ZoneArray_cntr_0), return -1;);
   13726           0 :                                 if (talloc_reference(object->ZoneArray, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, ZoneArray_cntr_0))) == NULL) {
   13727           0 :                                         PyErr_NoMemory();
   13728           0 :                                         return -1;
   13729             :                                 }
   13730           0 :                                 (object->ZoneArray)[ZoneArray_cntr_0] = (struct DNS_RPC_ZONE_W2K *)pytalloc_get_ptr(PyList_GET_ITEM(value, ZoneArray_cntr_0));
   13731             :                         }
   13732             :                 }
   13733             :         }
   13734           0 :         return 0;
   13735             : }
   13736             : 
   13737             : static PyGetSetDef py_DNS_RPC_ZONE_LIST_W2K_getsetters[] = {
   13738             :         {
   13739             :                 .name = discard_const_p(char, "dwZoneCount"),
   13740             :                 .get = py_DNS_RPC_ZONE_LIST_W2K_get_dwZoneCount,
   13741             :                 .set = py_DNS_RPC_ZONE_LIST_W2K_set_dwZoneCount,
   13742             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   13743             :         },
   13744             :         {
   13745             :                 .name = discard_const_p(char, "ZoneArray"),
   13746             :                 .get = py_DNS_RPC_ZONE_LIST_W2K_get_ZoneArray,
   13747             :                 .set = py_DNS_RPC_ZONE_LIST_W2K_set_ZoneArray,
   13748             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_ZONE_W2K")
   13749             :         },
   13750             :         { .name = NULL }
   13751             : };
   13752             : 
   13753           0 : static PyObject *py_DNS_RPC_ZONE_LIST_W2K_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   13754             : {
   13755           0 :         return pytalloc_new(struct DNS_RPC_ZONE_LIST_W2K, type);
   13756             : }
   13757             : 
   13758             : 
   13759             : static PyTypeObject DNS_RPC_ZONE_LIST_W2K_Type = {
   13760             :         PyVarObject_HEAD_INIT(NULL, 0)
   13761             :         .tp_name = "dnsserver.DNS_RPC_ZONE_LIST_W2K",
   13762             :         .tp_getset = py_DNS_RPC_ZONE_LIST_W2K_getsetters,
   13763             :         .tp_methods = NULL,
   13764             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   13765             :         .tp_new = py_DNS_RPC_ZONE_LIST_W2K_new,
   13766             : };
   13767             : 
   13768             : 
   13769           0 : static PyObject *py_DNS_RPC_ZONE_LIST_DOTNET_get_dwRpcStructureVersion(PyObject *obj, void *closure)
   13770             : {
   13771           0 :         struct DNS_RPC_ZONE_LIST_DOTNET *object = pytalloc_get_ptr(obj);
   13772           0 :         PyObject *py_dwRpcStructureVersion;
   13773           0 :         py_dwRpcStructureVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcStructureVersion));
   13774           0 :         return py_dwRpcStructureVersion;
   13775             : }
   13776             : 
   13777           0 : static int py_DNS_RPC_ZONE_LIST_DOTNET_set_dwRpcStructureVersion(PyObject *py_obj, PyObject *value, void *closure)
   13778             : {
   13779           0 :         struct DNS_RPC_ZONE_LIST_DOTNET *object = pytalloc_get_ptr(py_obj);
   13780           0 :         if (value == NULL) {
   13781           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcStructureVersion");
   13782           0 :                 return -1;
   13783             :         }
   13784             :         {
   13785           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcStructureVersion));
   13786           0 :                 if (PyLong_Check(value)) {
   13787           0 :                         unsigned long long test_var;
   13788           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   13789           0 :                         if (PyErr_Occurred() != NULL) {
   13790           0 :                                 return -1;
   13791             :                         }
   13792           0 :                         if (test_var > uint_max) {
   13793           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   13794             :                                   PyLong_Type.tp_name, uint_max, test_var);
   13795           0 :                                 return -1;
   13796             :                         }
   13797           0 :                         object->dwRpcStructureVersion = test_var;
   13798             :                 } else {
   13799           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   13800             :                           PyLong_Type.tp_name);
   13801           0 :                         return -1;
   13802             :                 }
   13803             :         }
   13804           0 :         return 0;
   13805             : }
   13806             : 
   13807           0 : static PyObject *py_DNS_RPC_ZONE_LIST_DOTNET_get_dwReserved0(PyObject *obj, void *closure)
   13808             : {
   13809           0 :         struct DNS_RPC_ZONE_LIST_DOTNET *object = pytalloc_get_ptr(obj);
   13810           0 :         PyObject *py_dwReserved0;
   13811           0 :         py_dwReserved0 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved0));
   13812           0 :         return py_dwReserved0;
   13813             : }
   13814             : 
   13815           0 : static int py_DNS_RPC_ZONE_LIST_DOTNET_set_dwReserved0(PyObject *py_obj, PyObject *value, void *closure)
   13816             : {
   13817           0 :         struct DNS_RPC_ZONE_LIST_DOTNET *object = pytalloc_get_ptr(py_obj);
   13818           0 :         if (value == NULL) {
   13819           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved0");
   13820           0 :                 return -1;
   13821             :         }
   13822             :         {
   13823           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved0));
   13824           0 :                 if (PyLong_Check(value)) {
   13825           0 :                         unsigned long long test_var;
   13826           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   13827           0 :                         if (PyErr_Occurred() != NULL) {
   13828           0 :                                 return -1;
   13829             :                         }
   13830           0 :                         if (test_var > uint_max) {
   13831           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   13832             :                                   PyLong_Type.tp_name, uint_max, test_var);
   13833           0 :                                 return -1;
   13834             :                         }
   13835           0 :                         object->dwReserved0 = test_var;
   13836             :                 } else {
   13837           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   13838             :                           PyLong_Type.tp_name);
   13839           0 :                         return -1;
   13840             :                 }
   13841             :         }
   13842           0 :         return 0;
   13843             : }
   13844             : 
   13845          14 : static PyObject *py_DNS_RPC_ZONE_LIST_DOTNET_get_dwZoneCount(PyObject *obj, void *closure)
   13846             : {
   13847          14 :         struct DNS_RPC_ZONE_LIST_DOTNET *object = pytalloc_get_ptr(obj);
   13848           0 :         PyObject *py_dwZoneCount;
   13849          14 :         py_dwZoneCount = PyLong_FromUnsignedLongLong((uint32_t)(object->dwZoneCount));
   13850          14 :         return py_dwZoneCount;
   13851             : }
   13852             : 
   13853           0 : static int py_DNS_RPC_ZONE_LIST_DOTNET_set_dwZoneCount(PyObject *py_obj, PyObject *value, void *closure)
   13854             : {
   13855           0 :         struct DNS_RPC_ZONE_LIST_DOTNET *object = pytalloc_get_ptr(py_obj);
   13856           0 :         if (value == NULL) {
   13857           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwZoneCount");
   13858           0 :                 return -1;
   13859             :         }
   13860             :         {
   13861           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwZoneCount));
   13862           0 :                 if (PyLong_Check(value)) {
   13863           0 :                         unsigned long long test_var;
   13864           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   13865           0 :                         if (PyErr_Occurred() != NULL) {
   13866           0 :                                 return -1;
   13867             :                         }
   13868           0 :                         if (test_var > uint_max) {
   13869           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   13870             :                                   PyLong_Type.tp_name, uint_max, test_var);
   13871           0 :                                 return -1;
   13872             :                         }
   13873           0 :                         object->dwZoneCount = test_var;
   13874             :                 } else {
   13875           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   13876             :                           PyLong_Type.tp_name);
   13877           0 :                         return -1;
   13878             :                 }
   13879             :         }
   13880           0 :         return 0;
   13881             : }
   13882             : 
   13883           5 : static PyObject *py_DNS_RPC_ZONE_LIST_DOTNET_get_ZoneArray(PyObject *obj, void *closure)
   13884             : {
   13885           5 :         struct DNS_RPC_ZONE_LIST_DOTNET *object = pytalloc_get_ptr(obj);
   13886           0 :         PyObject *py_ZoneArray;
   13887           5 :         py_ZoneArray = PyList_New(object->dwZoneCount);
   13888           5 :         if (py_ZoneArray == NULL) {
   13889           0 :                 return NULL;
   13890             :         }
   13891             :         {
   13892             :                 int ZoneArray_cntr_0;
   13893          23 :                 for (ZoneArray_cntr_0 = 0; ZoneArray_cntr_0 < (object->dwZoneCount); ZoneArray_cntr_0++) {
   13894           0 :                         PyObject *py_ZoneArray_0;
   13895          18 :                         if ((object->ZoneArray)[ZoneArray_cntr_0] == NULL) {
   13896           0 :                                 py_ZoneArray_0 = Py_None;
   13897           0 :                                 Py_INCREF(py_ZoneArray_0);
   13898             :                         } else {
   13899          18 :                                 py_ZoneArray_0 = pytalloc_reference_ex(&DNS_RPC_ZONE_DOTNET_Type, (object->ZoneArray)[ZoneArray_cntr_0], (object->ZoneArray)[ZoneArray_cntr_0]);
   13900             :                         }
   13901          18 :                         PyList_SetItem(py_ZoneArray, ZoneArray_cntr_0, py_ZoneArray_0);
   13902             :                 }
   13903             :         }
   13904           5 :         return py_ZoneArray;
   13905             : }
   13906             : 
   13907           0 : static int py_DNS_RPC_ZONE_LIST_DOTNET_set_ZoneArray(PyObject *py_obj, PyObject *value, void *closure)
   13908             : {
   13909           0 :         struct DNS_RPC_ZONE_LIST_DOTNET *object = pytalloc_get_ptr(py_obj);
   13910           0 :         if (value == NULL) {
   13911           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->ZoneArray");
   13912           0 :                 return -1;
   13913             :         }
   13914           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
   13915             :         {
   13916           0 :                 int ZoneArray_cntr_0;
   13917           0 :                 object->ZoneArray = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->ZoneArray, PyList_GET_SIZE(value));
   13918           0 :                 if (!object->ZoneArray) { return -1; }
   13919           0 :                 talloc_set_name_const(object->ZoneArray, "ARRAY: object->ZoneArray");
   13920           0 :                 for (ZoneArray_cntr_0 = 0; ZoneArray_cntr_0 < PyList_GET_SIZE(value); ZoneArray_cntr_0++) {
   13921           0 :                         if (PyList_GET_ITEM(value, ZoneArray_cntr_0) == NULL) {
   13922           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->ZoneArray)[ZoneArray_cntr_0]");
   13923           0 :                                 return -1;
   13924             :                         }
   13925           0 :                         if (PyList_GET_ITEM(value, ZoneArray_cntr_0) == Py_None) {
   13926           0 :                                 (object->ZoneArray)[ZoneArray_cntr_0] = NULL;
   13927             :                         } else {
   13928           0 :                                 (object->ZoneArray)[ZoneArray_cntr_0] = NULL;
   13929           0 :                                 PY_CHECK_TYPE(&DNS_RPC_ZONE_DOTNET_Type, PyList_GET_ITEM(value, ZoneArray_cntr_0), return -1;);
   13930           0 :                                 if (talloc_reference(object->ZoneArray, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, ZoneArray_cntr_0))) == NULL) {
   13931           0 :                                         PyErr_NoMemory();
   13932           0 :                                         return -1;
   13933             :                                 }
   13934           0 :                                 (object->ZoneArray)[ZoneArray_cntr_0] = (struct DNS_RPC_ZONE_DOTNET *)pytalloc_get_ptr(PyList_GET_ITEM(value, ZoneArray_cntr_0));
   13935             :                         }
   13936             :                 }
   13937             :         }
   13938           0 :         return 0;
   13939             : }
   13940             : 
   13941             : static PyGetSetDef py_DNS_RPC_ZONE_LIST_DOTNET_getsetters[] = {
   13942             :         {
   13943             :                 .name = discard_const_p(char, "dwRpcStructureVersion"),
   13944             :                 .get = py_DNS_RPC_ZONE_LIST_DOTNET_get_dwRpcStructureVersion,
   13945             :                 .set = py_DNS_RPC_ZONE_LIST_DOTNET_set_dwRpcStructureVersion,
   13946             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   13947             :         },
   13948             :         {
   13949             :                 .name = discard_const_p(char, "dwReserved0"),
   13950             :                 .get = py_DNS_RPC_ZONE_LIST_DOTNET_get_dwReserved0,
   13951             :                 .set = py_DNS_RPC_ZONE_LIST_DOTNET_set_dwReserved0,
   13952             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   13953             :         },
   13954             :         {
   13955             :                 .name = discard_const_p(char, "dwZoneCount"),
   13956             :                 .get = py_DNS_RPC_ZONE_LIST_DOTNET_get_dwZoneCount,
   13957             :                 .set = py_DNS_RPC_ZONE_LIST_DOTNET_set_dwZoneCount,
   13958             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   13959             :         },
   13960             :         {
   13961             :                 .name = discard_const_p(char, "ZoneArray"),
   13962             :                 .get = py_DNS_RPC_ZONE_LIST_DOTNET_get_ZoneArray,
   13963             :                 .set = py_DNS_RPC_ZONE_LIST_DOTNET_set_ZoneArray,
   13964             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_ZONE_DOTNET")
   13965             :         },
   13966             :         { .name = NULL }
   13967             : };
   13968             : 
   13969           0 : static PyObject *py_DNS_RPC_ZONE_LIST_DOTNET_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   13970             : {
   13971           0 :         return pytalloc_new(struct DNS_RPC_ZONE_LIST_DOTNET, type);
   13972             : }
   13973             : 
   13974             : 
   13975             : static PyTypeObject DNS_RPC_ZONE_LIST_DOTNET_Type = {
   13976             :         PyVarObject_HEAD_INIT(NULL, 0)
   13977             :         .tp_name = "dnsserver.DNS_RPC_ZONE_LIST_DOTNET",
   13978             :         .tp_getset = py_DNS_RPC_ZONE_LIST_DOTNET_getsetters,
   13979             :         .tp_methods = NULL,
   13980             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   13981             :         .tp_new = py_DNS_RPC_ZONE_LIST_DOTNET_new,
   13982             : };
   13983             : 
   13984             : 
   13985           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_pszZoneName(PyObject *obj, void *closure)
   13986             : {
   13987           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   13988           0 :         PyObject *py_pszZoneName;
   13989           0 :         if (object->pszZoneName == NULL) {
   13990           0 :                 Py_RETURN_NONE;
   13991             :         }
   13992           0 :         if (object->pszZoneName == NULL) {
   13993           0 :                 py_pszZoneName = Py_None;
   13994           0 :                 Py_INCREF(py_pszZoneName);
   13995             :         } else {
   13996           0 :                 if (object->pszZoneName == NULL) {
   13997           0 :                         py_pszZoneName = Py_None;
   13998           0 :                         Py_INCREF(py_pszZoneName);
   13999             :                 } else {
   14000           0 :                         py_pszZoneName = PyUnicode_Decode(object->pszZoneName, strlen(object->pszZoneName), "utf-8", "ignore");
   14001             :                 }
   14002             :         }
   14003           0 :         return py_pszZoneName;
   14004             : }
   14005             : 
   14006           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_pszZoneName(PyObject *py_obj, PyObject *value, void *closure)
   14007             : {
   14008           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14009           0 :         if (value == NULL) {
   14010           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszZoneName");
   14011           0 :                 return -1;
   14012             :         }
   14013           0 :         if (value == Py_None) {
   14014           0 :                 object->pszZoneName = NULL;
   14015             :         } else {
   14016           0 :                 object->pszZoneName = NULL;
   14017             :                 {
   14018           0 :                         const char *test_str;
   14019           0 :                         const char *talloc_str;
   14020           0 :                         PyObject *unicode = NULL;
   14021           0 :                         if (PyUnicode_Check(value)) {
   14022           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   14023           0 :                                 if (unicode == NULL) {
   14024           0 :                                         return -1;
   14025             :                                 }
   14026           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   14027           0 :                         } else if (PyBytes_Check(value)) {
   14028           0 :                                 test_str = PyBytes_AS_STRING(value);
   14029             :                         } else {
   14030           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   14031           0 :                                 return -1;
   14032             :                         }
   14033           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   14034           0 :                         if (unicode != NULL) {
   14035           0 :                                 Py_DECREF(unicode);
   14036             :                         }
   14037           0 :                         if (talloc_str == NULL) {
   14038           0 :                                 PyErr_NoMemory();
   14039           0 :                                 return -1;
   14040             :                         }
   14041           0 :                         object->pszZoneName = talloc_str;
   14042             :                 }
   14043             :         }
   14044           0 :         return 0;
   14045             : }
   14046             : 
   14047           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_dwZoneType(PyObject *obj, void *closure)
   14048             : {
   14049           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   14050           0 :         PyObject *py_dwZoneType;
   14051           0 :         py_dwZoneType = PyLong_FromUnsignedLongLong((uint32_t)(object->dwZoneType));
   14052           0 :         return py_dwZoneType;
   14053             : }
   14054             : 
   14055           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_dwZoneType(PyObject *py_obj, PyObject *value, void *closure)
   14056             : {
   14057           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14058           0 :         if (value == NULL) {
   14059           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwZoneType");
   14060           0 :                 return -1;
   14061             :         }
   14062             :         {
   14063           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwZoneType));
   14064           0 :                 if (PyLong_Check(value)) {
   14065           0 :                         unsigned long long test_var;
   14066           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   14067           0 :                         if (PyErr_Occurred() != NULL) {
   14068           0 :                                 return -1;
   14069             :                         }
   14070           0 :                         if (test_var > uint_max) {
   14071           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   14072             :                                   PyLong_Type.tp_name, uint_max, test_var);
   14073           0 :                                 return -1;
   14074             :                         }
   14075           0 :                         object->dwZoneType = test_var;
   14076             :                 } else {
   14077           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   14078             :                           PyLong_Type.tp_name);
   14079           0 :                         return -1;
   14080             :                 }
   14081             :         }
   14082           0 :         return 0;
   14083             : }
   14084             : 
   14085           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_fReverse(PyObject *obj, void *closure)
   14086             : {
   14087           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   14088           0 :         PyObject *py_fReverse;
   14089           0 :         py_fReverse = PyLong_FromUnsignedLongLong((uint32_t)(object->fReverse));
   14090           0 :         return py_fReverse;
   14091             : }
   14092             : 
   14093           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_fReverse(PyObject *py_obj, PyObject *value, void *closure)
   14094             : {
   14095           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14096           0 :         if (value == NULL) {
   14097           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fReverse");
   14098           0 :                 return -1;
   14099             :         }
   14100             :         {
   14101           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fReverse));
   14102           0 :                 if (PyLong_Check(value)) {
   14103           0 :                         unsigned long long test_var;
   14104           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   14105           0 :                         if (PyErr_Occurred() != NULL) {
   14106           0 :                                 return -1;
   14107             :                         }
   14108           0 :                         if (test_var > uint_max) {
   14109           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   14110             :                                   PyLong_Type.tp_name, uint_max, test_var);
   14111           0 :                                 return -1;
   14112             :                         }
   14113           0 :                         object->fReverse = test_var;
   14114             :                 } else {
   14115           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   14116             :                           PyLong_Type.tp_name);
   14117           0 :                         return -1;
   14118             :                 }
   14119             :         }
   14120           0 :         return 0;
   14121             : }
   14122             : 
   14123           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_fAllowUpdate(PyObject *obj, void *closure)
   14124             : {
   14125           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   14126           0 :         PyObject *py_fAllowUpdate;
   14127           0 :         py_fAllowUpdate = PyLong_FromLong((uint16_t)(object->fAllowUpdate));
   14128           0 :         return py_fAllowUpdate;
   14129             : }
   14130             : 
   14131           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_fAllowUpdate(PyObject *py_obj, PyObject *value, void *closure)
   14132             : {
   14133           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14134           0 :         if (value == NULL) {
   14135           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAllowUpdate");
   14136           0 :                 return -1;
   14137             :         }
   14138             :         {
   14139           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAllowUpdate));
   14140           0 :                 if (PyLong_Check(value)) {
   14141           0 :                         unsigned long long test_var;
   14142           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   14143           0 :                         if (PyErr_Occurred() != NULL) {
   14144           0 :                                 return -1;
   14145             :                         }
   14146           0 :                         if (test_var > uint_max) {
   14147           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   14148             :                                   PyLong_Type.tp_name, uint_max, test_var);
   14149           0 :                                 return -1;
   14150             :                         }
   14151           0 :                         object->fAllowUpdate = test_var;
   14152             :                 } else {
   14153           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   14154             :                           PyLong_Type.tp_name);
   14155           0 :                         return -1;
   14156             :                 }
   14157             :         }
   14158           0 :         return 0;
   14159             : }
   14160             : 
   14161           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_fPaused(PyObject *obj, void *closure)
   14162             : {
   14163           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   14164           0 :         PyObject *py_fPaused;
   14165           0 :         py_fPaused = PyLong_FromUnsignedLongLong((uint32_t)(object->fPaused));
   14166           0 :         return py_fPaused;
   14167             : }
   14168             : 
   14169           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_fPaused(PyObject *py_obj, PyObject *value, void *closure)
   14170             : {
   14171           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14172           0 :         if (value == NULL) {
   14173           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fPaused");
   14174           0 :                 return -1;
   14175             :         }
   14176             :         {
   14177           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fPaused));
   14178           0 :                 if (PyLong_Check(value)) {
   14179           0 :                         unsigned long long test_var;
   14180           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   14181           0 :                         if (PyErr_Occurred() != NULL) {
   14182           0 :                                 return -1;
   14183             :                         }
   14184           0 :                         if (test_var > uint_max) {
   14185           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   14186             :                                   PyLong_Type.tp_name, uint_max, test_var);
   14187           0 :                                 return -1;
   14188             :                         }
   14189           0 :                         object->fPaused = test_var;
   14190             :                 } else {
   14191           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   14192             :                           PyLong_Type.tp_name);
   14193           0 :                         return -1;
   14194             :                 }
   14195             :         }
   14196           0 :         return 0;
   14197             : }
   14198             : 
   14199           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_fShutdown(PyObject *obj, void *closure)
   14200             : {
   14201           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   14202           0 :         PyObject *py_fShutdown;
   14203           0 :         py_fShutdown = PyLong_FromUnsignedLongLong((uint32_t)(object->fShutdown));
   14204           0 :         return py_fShutdown;
   14205             : }
   14206             : 
   14207           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_fShutdown(PyObject *py_obj, PyObject *value, void *closure)
   14208             : {
   14209           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14210           0 :         if (value == NULL) {
   14211           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fShutdown");
   14212           0 :                 return -1;
   14213             :         }
   14214             :         {
   14215           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fShutdown));
   14216           0 :                 if (PyLong_Check(value)) {
   14217           0 :                         unsigned long long test_var;
   14218           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   14219           0 :                         if (PyErr_Occurred() != NULL) {
   14220           0 :                                 return -1;
   14221             :                         }
   14222           0 :                         if (test_var > uint_max) {
   14223           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   14224             :                                   PyLong_Type.tp_name, uint_max, test_var);
   14225           0 :                                 return -1;
   14226             :                         }
   14227           0 :                         object->fShutdown = test_var;
   14228             :                 } else {
   14229           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   14230             :                           PyLong_Type.tp_name);
   14231           0 :                         return -1;
   14232             :                 }
   14233             :         }
   14234           0 :         return 0;
   14235             : }
   14236             : 
   14237           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_fAutoCreated(PyObject *obj, void *closure)
   14238             : {
   14239           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   14240           0 :         PyObject *py_fAutoCreated;
   14241           0 :         py_fAutoCreated = PyLong_FromUnsignedLongLong((uint32_t)(object->fAutoCreated));
   14242           0 :         return py_fAutoCreated;
   14243             : }
   14244             : 
   14245           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_fAutoCreated(PyObject *py_obj, PyObject *value, void *closure)
   14246             : {
   14247           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14248           0 :         if (value == NULL) {
   14249           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAutoCreated");
   14250           0 :                 return -1;
   14251             :         }
   14252             :         {
   14253           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAutoCreated));
   14254           0 :                 if (PyLong_Check(value)) {
   14255           0 :                         unsigned long long test_var;
   14256           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   14257           0 :                         if (PyErr_Occurred() != NULL) {
   14258           0 :                                 return -1;
   14259             :                         }
   14260           0 :                         if (test_var > uint_max) {
   14261           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   14262             :                                   PyLong_Type.tp_name, uint_max, test_var);
   14263           0 :                                 return -1;
   14264             :                         }
   14265           0 :                         object->fAutoCreated = test_var;
   14266             :                 } else {
   14267           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   14268             :                           PyLong_Type.tp_name);
   14269           0 :                         return -1;
   14270             :                 }
   14271             :         }
   14272           0 :         return 0;
   14273             : }
   14274             : 
   14275           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_fUseDatabase(PyObject *obj, void *closure)
   14276             : {
   14277           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   14278           0 :         PyObject *py_fUseDatabase;
   14279           0 :         py_fUseDatabase = PyLong_FromUnsignedLongLong((uint32_t)(object->fUseDatabase));
   14280           0 :         return py_fUseDatabase;
   14281             : }
   14282             : 
   14283           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_fUseDatabase(PyObject *py_obj, PyObject *value, void *closure)
   14284             : {
   14285           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14286           0 :         if (value == NULL) {
   14287           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fUseDatabase");
   14288           0 :                 return -1;
   14289             :         }
   14290             :         {
   14291           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fUseDatabase));
   14292           0 :                 if (PyLong_Check(value)) {
   14293           0 :                         unsigned long long test_var;
   14294           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   14295           0 :                         if (PyErr_Occurred() != NULL) {
   14296           0 :                                 return -1;
   14297             :                         }
   14298           0 :                         if (test_var > uint_max) {
   14299           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   14300             :                                   PyLong_Type.tp_name, uint_max, test_var);
   14301           0 :                                 return -1;
   14302             :                         }
   14303           0 :                         object->fUseDatabase = test_var;
   14304             :                 } else {
   14305           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   14306             :                           PyLong_Type.tp_name);
   14307           0 :                         return -1;
   14308             :                 }
   14309             :         }
   14310           0 :         return 0;
   14311             : }
   14312             : 
   14313           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_pszDataFile(PyObject *obj, void *closure)
   14314             : {
   14315           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   14316           0 :         PyObject *py_pszDataFile;
   14317           0 :         if (object->pszDataFile == NULL) {
   14318           0 :                 Py_RETURN_NONE;
   14319             :         }
   14320           0 :         if (object->pszDataFile == NULL) {
   14321           0 :                 py_pszDataFile = Py_None;
   14322           0 :                 Py_INCREF(py_pszDataFile);
   14323             :         } else {
   14324           0 :                 if (object->pszDataFile == NULL) {
   14325           0 :                         py_pszDataFile = Py_None;
   14326           0 :                         Py_INCREF(py_pszDataFile);
   14327             :                 } else {
   14328           0 :                         py_pszDataFile = PyUnicode_Decode(object->pszDataFile, strlen(object->pszDataFile), "utf-8", "ignore");
   14329             :                 }
   14330             :         }
   14331           0 :         return py_pszDataFile;
   14332             : }
   14333             : 
   14334           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_pszDataFile(PyObject *py_obj, PyObject *value, void *closure)
   14335             : {
   14336           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14337           0 :         if (value == NULL) {
   14338           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszDataFile");
   14339           0 :                 return -1;
   14340             :         }
   14341           0 :         if (value == Py_None) {
   14342           0 :                 object->pszDataFile = NULL;
   14343             :         } else {
   14344           0 :                 object->pszDataFile = NULL;
   14345             :                 {
   14346           0 :                         const char *test_str;
   14347           0 :                         const char *talloc_str;
   14348           0 :                         PyObject *unicode = NULL;
   14349           0 :                         if (PyUnicode_Check(value)) {
   14350           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   14351           0 :                                 if (unicode == NULL) {
   14352           0 :                                         return -1;
   14353             :                                 }
   14354           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   14355           0 :                         } else if (PyBytes_Check(value)) {
   14356           0 :                                 test_str = PyBytes_AS_STRING(value);
   14357             :                         } else {
   14358           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   14359           0 :                                 return -1;
   14360             :                         }
   14361           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   14362           0 :                         if (unicode != NULL) {
   14363           0 :                                 Py_DECREF(unicode);
   14364             :                         }
   14365           0 :                         if (talloc_str == NULL) {
   14366           0 :                                 PyErr_NoMemory();
   14367           0 :                                 return -1;
   14368             :                         }
   14369           0 :                         object->pszDataFile = talloc_str;
   14370             :                 }
   14371             :         }
   14372           0 :         return 0;
   14373             : }
   14374             : 
   14375           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_aipMasters(PyObject *obj, void *closure)
   14376             : {
   14377           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   14378           0 :         PyObject *py_aipMasters;
   14379           0 :         if (object->aipMasters == NULL) {
   14380           0 :                 Py_RETURN_NONE;
   14381             :         }
   14382           0 :         if (object->aipMasters == NULL) {
   14383           0 :                 py_aipMasters = Py_None;
   14384           0 :                 Py_INCREF(py_aipMasters);
   14385             :         } else {
   14386           0 :                 py_aipMasters = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipMasters, object->aipMasters);
   14387             :         }
   14388           0 :         return py_aipMasters;
   14389             : }
   14390             : 
   14391           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_aipMasters(PyObject *py_obj, PyObject *value, void *closure)
   14392             : {
   14393           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14394           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipMasters));
   14395           0 :         if (value == NULL) {
   14396           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipMasters");
   14397           0 :                 return -1;
   14398             :         }
   14399           0 :         if (value == Py_None) {
   14400           0 :                 object->aipMasters = NULL;
   14401             :         } else {
   14402           0 :                 object->aipMasters = NULL;
   14403           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
   14404           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   14405           0 :                         PyErr_NoMemory();
   14406           0 :                         return -1;
   14407             :                 }
   14408           0 :                 object->aipMasters = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
   14409             :         }
   14410           0 :         return 0;
   14411             : }
   14412             : 
   14413           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_fSecureSecondaries(PyObject *obj, void *closure)
   14414             : {
   14415           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   14416           0 :         PyObject *py_fSecureSecondaries;
   14417           0 :         py_fSecureSecondaries = PyLong_FromUnsignedLongLong((uint32_t)(object->fSecureSecondaries));
   14418           0 :         return py_fSecureSecondaries;
   14419             : }
   14420             : 
   14421           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_fSecureSecondaries(PyObject *py_obj, PyObject *value, void *closure)
   14422             : {
   14423           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14424           0 :         if (value == NULL) {
   14425           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fSecureSecondaries");
   14426           0 :                 return -1;
   14427             :         }
   14428             :         {
   14429           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fSecureSecondaries));
   14430           0 :                 if (PyLong_Check(value)) {
   14431           0 :                         unsigned long long test_var;
   14432           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   14433           0 :                         if (PyErr_Occurred() != NULL) {
   14434           0 :                                 return -1;
   14435             :                         }
   14436           0 :                         if (test_var > uint_max) {
   14437           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   14438             :                                   PyLong_Type.tp_name, uint_max, test_var);
   14439           0 :                                 return -1;
   14440             :                         }
   14441           0 :                         object->fSecureSecondaries = test_var;
   14442             :                 } else {
   14443           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   14444             :                           PyLong_Type.tp_name);
   14445           0 :                         return -1;
   14446             :                 }
   14447             :         }
   14448           0 :         return 0;
   14449             : }
   14450             : 
   14451           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_fNotifyLevel(PyObject *obj, void *closure)
   14452             : {
   14453           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   14454           0 :         PyObject *py_fNotifyLevel;
   14455           0 :         py_fNotifyLevel = PyLong_FromUnsignedLongLong((uint32_t)(object->fNotifyLevel));
   14456           0 :         return py_fNotifyLevel;
   14457             : }
   14458             : 
   14459           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_fNotifyLevel(PyObject *py_obj, PyObject *value, void *closure)
   14460             : {
   14461           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14462           0 :         if (value == NULL) {
   14463           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fNotifyLevel");
   14464           0 :                 return -1;
   14465             :         }
   14466             :         {
   14467           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fNotifyLevel));
   14468           0 :                 if (PyLong_Check(value)) {
   14469           0 :                         unsigned long long test_var;
   14470           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   14471           0 :                         if (PyErr_Occurred() != NULL) {
   14472           0 :                                 return -1;
   14473             :                         }
   14474           0 :                         if (test_var > uint_max) {
   14475           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   14476             :                                   PyLong_Type.tp_name, uint_max, test_var);
   14477           0 :                                 return -1;
   14478             :                         }
   14479           0 :                         object->fNotifyLevel = test_var;
   14480             :                 } else {
   14481           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   14482             :                           PyLong_Type.tp_name);
   14483           0 :                         return -1;
   14484             :                 }
   14485             :         }
   14486           0 :         return 0;
   14487             : }
   14488             : 
   14489           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_aipSecondaries(PyObject *obj, void *closure)
   14490             : {
   14491           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   14492           0 :         PyObject *py_aipSecondaries;
   14493           0 :         if (object->aipSecondaries == NULL) {
   14494           0 :                 Py_RETURN_NONE;
   14495             :         }
   14496           0 :         if (object->aipSecondaries == NULL) {
   14497           0 :                 py_aipSecondaries = Py_None;
   14498           0 :                 Py_INCREF(py_aipSecondaries);
   14499             :         } else {
   14500           0 :                 py_aipSecondaries = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipSecondaries, object->aipSecondaries);
   14501             :         }
   14502           0 :         return py_aipSecondaries;
   14503             : }
   14504             : 
   14505           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_aipSecondaries(PyObject *py_obj, PyObject *value, void *closure)
   14506             : {
   14507           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14508           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipSecondaries));
   14509           0 :         if (value == NULL) {
   14510           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipSecondaries");
   14511           0 :                 return -1;
   14512             :         }
   14513           0 :         if (value == Py_None) {
   14514           0 :                 object->aipSecondaries = NULL;
   14515             :         } else {
   14516           0 :                 object->aipSecondaries = NULL;
   14517           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
   14518           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   14519           0 :                         PyErr_NoMemory();
   14520           0 :                         return -1;
   14521             :                 }
   14522           0 :                 object->aipSecondaries = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
   14523             :         }
   14524           0 :         return 0;
   14525             : }
   14526             : 
   14527           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_aipNotify(PyObject *obj, void *closure)
   14528             : {
   14529           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   14530           0 :         PyObject *py_aipNotify;
   14531           0 :         if (object->aipNotify == NULL) {
   14532           0 :                 Py_RETURN_NONE;
   14533             :         }
   14534           0 :         if (object->aipNotify == NULL) {
   14535           0 :                 py_aipNotify = Py_None;
   14536           0 :                 Py_INCREF(py_aipNotify);
   14537             :         } else {
   14538           0 :                 py_aipNotify = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipNotify, object->aipNotify);
   14539             :         }
   14540           0 :         return py_aipNotify;
   14541             : }
   14542             : 
   14543           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_aipNotify(PyObject *py_obj, PyObject *value, void *closure)
   14544             : {
   14545           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14546           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipNotify));
   14547           0 :         if (value == NULL) {
   14548           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipNotify");
   14549           0 :                 return -1;
   14550             :         }
   14551           0 :         if (value == Py_None) {
   14552           0 :                 object->aipNotify = NULL;
   14553             :         } else {
   14554           0 :                 object->aipNotify = NULL;
   14555           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
   14556           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   14557           0 :                         PyErr_NoMemory();
   14558           0 :                         return -1;
   14559             :                 }
   14560           0 :                 object->aipNotify = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
   14561             :         }
   14562           0 :         return 0;
   14563             : }
   14564             : 
   14565           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_fUseWins(PyObject *obj, void *closure)
   14566             : {
   14567           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   14568           0 :         PyObject *py_fUseWins;
   14569           0 :         py_fUseWins = PyLong_FromUnsignedLongLong((uint32_t)(object->fUseWins));
   14570           0 :         return py_fUseWins;
   14571             : }
   14572             : 
   14573           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_fUseWins(PyObject *py_obj, PyObject *value, void *closure)
   14574             : {
   14575           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14576           0 :         if (value == NULL) {
   14577           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fUseWins");
   14578           0 :                 return -1;
   14579             :         }
   14580             :         {
   14581           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fUseWins));
   14582           0 :                 if (PyLong_Check(value)) {
   14583           0 :                         unsigned long long test_var;
   14584           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   14585           0 :                         if (PyErr_Occurred() != NULL) {
   14586           0 :                                 return -1;
   14587             :                         }
   14588           0 :                         if (test_var > uint_max) {
   14589           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   14590             :                                   PyLong_Type.tp_name, uint_max, test_var);
   14591           0 :                                 return -1;
   14592             :                         }
   14593           0 :                         object->fUseWins = test_var;
   14594             :                 } else {
   14595           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   14596             :                           PyLong_Type.tp_name);
   14597           0 :                         return -1;
   14598             :                 }
   14599             :         }
   14600           0 :         return 0;
   14601             : }
   14602             : 
   14603           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_fUseNbstat(PyObject *obj, void *closure)
   14604             : {
   14605           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   14606           0 :         PyObject *py_fUseNbstat;
   14607           0 :         py_fUseNbstat = PyLong_FromUnsignedLongLong((uint32_t)(object->fUseNbstat));
   14608           0 :         return py_fUseNbstat;
   14609             : }
   14610             : 
   14611           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_fUseNbstat(PyObject *py_obj, PyObject *value, void *closure)
   14612             : {
   14613           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14614           0 :         if (value == NULL) {
   14615           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fUseNbstat");
   14616           0 :                 return -1;
   14617             :         }
   14618             :         {
   14619           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fUseNbstat));
   14620           0 :                 if (PyLong_Check(value)) {
   14621           0 :                         unsigned long long test_var;
   14622           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   14623           0 :                         if (PyErr_Occurred() != NULL) {
   14624           0 :                                 return -1;
   14625             :                         }
   14626           0 :                         if (test_var > uint_max) {
   14627           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   14628             :                                   PyLong_Type.tp_name, uint_max, test_var);
   14629           0 :                                 return -1;
   14630             :                         }
   14631           0 :                         object->fUseNbstat = test_var;
   14632             :                 } else {
   14633           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   14634             :                           PyLong_Type.tp_name);
   14635           0 :                         return -1;
   14636             :                 }
   14637             :         }
   14638           0 :         return 0;
   14639             : }
   14640             : 
   14641           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_fAging(PyObject *obj, void *closure)
   14642             : {
   14643           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   14644           0 :         PyObject *py_fAging;
   14645           0 :         py_fAging = PyLong_FromUnsignedLongLong((uint32_t)(object->fAging));
   14646           0 :         return py_fAging;
   14647             : }
   14648             : 
   14649           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_fAging(PyObject *py_obj, PyObject *value, void *closure)
   14650             : {
   14651           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14652           0 :         if (value == NULL) {
   14653           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAging");
   14654           0 :                 return -1;
   14655             :         }
   14656             :         {
   14657           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAging));
   14658           0 :                 if (PyLong_Check(value)) {
   14659           0 :                         unsigned long long test_var;
   14660           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   14661           0 :                         if (PyErr_Occurred() != NULL) {
   14662           0 :                                 return -1;
   14663             :                         }
   14664           0 :                         if (test_var > uint_max) {
   14665           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   14666             :                                   PyLong_Type.tp_name, uint_max, test_var);
   14667           0 :                                 return -1;
   14668             :                         }
   14669           0 :                         object->fAging = test_var;
   14670             :                 } else {
   14671           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   14672             :                           PyLong_Type.tp_name);
   14673           0 :                         return -1;
   14674             :                 }
   14675             :         }
   14676           0 :         return 0;
   14677             : }
   14678             : 
   14679           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_dwNoRefreshInterval(PyObject *obj, void *closure)
   14680             : {
   14681           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   14682           0 :         PyObject *py_dwNoRefreshInterval;
   14683           0 :         py_dwNoRefreshInterval = PyLong_FromUnsignedLongLong((uint32_t)(object->dwNoRefreshInterval));
   14684           0 :         return py_dwNoRefreshInterval;
   14685             : }
   14686             : 
   14687           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_dwNoRefreshInterval(PyObject *py_obj, PyObject *value, void *closure)
   14688             : {
   14689           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14690           0 :         if (value == NULL) {
   14691           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwNoRefreshInterval");
   14692           0 :                 return -1;
   14693             :         }
   14694             :         {
   14695           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwNoRefreshInterval));
   14696           0 :                 if (PyLong_Check(value)) {
   14697           0 :                         unsigned long long test_var;
   14698           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   14699           0 :                         if (PyErr_Occurred() != NULL) {
   14700           0 :                                 return -1;
   14701             :                         }
   14702           0 :                         if (test_var > uint_max) {
   14703           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   14704             :                                   PyLong_Type.tp_name, uint_max, test_var);
   14705           0 :                                 return -1;
   14706             :                         }
   14707           0 :                         object->dwNoRefreshInterval = test_var;
   14708             :                 } else {
   14709           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   14710             :                           PyLong_Type.tp_name);
   14711           0 :                         return -1;
   14712             :                 }
   14713             :         }
   14714           0 :         return 0;
   14715             : }
   14716             : 
   14717           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_dwRefreshInterval(PyObject *obj, void *closure)
   14718             : {
   14719           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   14720           0 :         PyObject *py_dwRefreshInterval;
   14721           0 :         py_dwRefreshInterval = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRefreshInterval));
   14722           0 :         return py_dwRefreshInterval;
   14723             : }
   14724             : 
   14725           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_dwRefreshInterval(PyObject *py_obj, PyObject *value, void *closure)
   14726             : {
   14727           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14728           0 :         if (value == NULL) {
   14729           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRefreshInterval");
   14730           0 :                 return -1;
   14731             :         }
   14732             :         {
   14733           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRefreshInterval));
   14734           0 :                 if (PyLong_Check(value)) {
   14735           0 :                         unsigned long long test_var;
   14736           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   14737           0 :                         if (PyErr_Occurred() != NULL) {
   14738           0 :                                 return -1;
   14739             :                         }
   14740           0 :                         if (test_var > uint_max) {
   14741           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   14742             :                                   PyLong_Type.tp_name, uint_max, test_var);
   14743           0 :                                 return -1;
   14744             :                         }
   14745           0 :                         object->dwRefreshInterval = test_var;
   14746             :                 } else {
   14747           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   14748             :                           PyLong_Type.tp_name);
   14749           0 :                         return -1;
   14750             :                 }
   14751             :         }
   14752           0 :         return 0;
   14753             : }
   14754             : 
   14755           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_dwAvailForScavengeTime(PyObject *obj, void *closure)
   14756             : {
   14757           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   14758           0 :         PyObject *py_dwAvailForScavengeTime;
   14759           0 :         py_dwAvailForScavengeTime = PyLong_FromUnsignedLongLong((uint32_t)(object->dwAvailForScavengeTime));
   14760           0 :         return py_dwAvailForScavengeTime;
   14761             : }
   14762             : 
   14763           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_dwAvailForScavengeTime(PyObject *py_obj, PyObject *value, void *closure)
   14764             : {
   14765           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14766           0 :         if (value == NULL) {
   14767           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwAvailForScavengeTime");
   14768           0 :                 return -1;
   14769             :         }
   14770             :         {
   14771           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwAvailForScavengeTime));
   14772           0 :                 if (PyLong_Check(value)) {
   14773           0 :                         unsigned long long test_var;
   14774           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   14775           0 :                         if (PyErr_Occurred() != NULL) {
   14776           0 :                                 return -1;
   14777             :                         }
   14778           0 :                         if (test_var > uint_max) {
   14779           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   14780             :                                   PyLong_Type.tp_name, uint_max, test_var);
   14781           0 :                                 return -1;
   14782             :                         }
   14783           0 :                         object->dwAvailForScavengeTime = test_var;
   14784             :                 } else {
   14785           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   14786             :                           PyLong_Type.tp_name);
   14787           0 :                         return -1;
   14788             :                 }
   14789             :         }
   14790           0 :         return 0;
   14791             : }
   14792             : 
   14793           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_aipScavengeServers(PyObject *obj, void *closure)
   14794             : {
   14795           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   14796           0 :         PyObject *py_aipScavengeServers;
   14797           0 :         if (object->aipScavengeServers == NULL) {
   14798           0 :                 Py_RETURN_NONE;
   14799             :         }
   14800           0 :         if (object->aipScavengeServers == NULL) {
   14801           0 :                 py_aipScavengeServers = Py_None;
   14802           0 :                 Py_INCREF(py_aipScavengeServers);
   14803             :         } else {
   14804           0 :                 py_aipScavengeServers = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipScavengeServers, object->aipScavengeServers);
   14805             :         }
   14806           0 :         return py_aipScavengeServers;
   14807             : }
   14808             : 
   14809           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_aipScavengeServers(PyObject *py_obj, PyObject *value, void *closure)
   14810             : {
   14811           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14812           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipScavengeServers));
   14813           0 :         if (value == NULL) {
   14814           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipScavengeServers");
   14815           0 :                 return -1;
   14816             :         }
   14817           0 :         if (value == Py_None) {
   14818           0 :                 object->aipScavengeServers = NULL;
   14819             :         } else {
   14820           0 :                 object->aipScavengeServers = NULL;
   14821           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
   14822           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   14823           0 :                         PyErr_NoMemory();
   14824           0 :                         return -1;
   14825             :                 }
   14826           0 :                 object->aipScavengeServers = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
   14827             :         }
   14828           0 :         return 0;
   14829             : }
   14830             : 
   14831           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_pvReserved1(PyObject *obj, void *closure)
   14832             : {
   14833           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   14834           0 :         PyObject *py_pvReserved1;
   14835           0 :         py_pvReserved1 = PyLong_FromUnsignedLongLong((uint32_t)(object->pvReserved1));
   14836           0 :         return py_pvReserved1;
   14837             : }
   14838             : 
   14839           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_pvReserved1(PyObject *py_obj, PyObject *value, void *closure)
   14840             : {
   14841           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14842           0 :         if (value == NULL) {
   14843           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pvReserved1");
   14844           0 :                 return -1;
   14845             :         }
   14846             :         {
   14847           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->pvReserved1));
   14848           0 :                 if (PyLong_Check(value)) {
   14849           0 :                         unsigned long long test_var;
   14850           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   14851           0 :                         if (PyErr_Occurred() != NULL) {
   14852           0 :                                 return -1;
   14853             :                         }
   14854           0 :                         if (test_var > uint_max) {
   14855           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   14856             :                                   PyLong_Type.tp_name, uint_max, test_var);
   14857           0 :                                 return -1;
   14858             :                         }
   14859           0 :                         object->pvReserved1 = test_var;
   14860             :                 } else {
   14861           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   14862             :                           PyLong_Type.tp_name);
   14863           0 :                         return -1;
   14864             :                 }
   14865             :         }
   14866           0 :         return 0;
   14867             : }
   14868             : 
   14869           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_pvReserved2(PyObject *obj, void *closure)
   14870             : {
   14871           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   14872           0 :         PyObject *py_pvReserved2;
   14873           0 :         py_pvReserved2 = PyLong_FromUnsignedLongLong((uint32_t)(object->pvReserved2));
   14874           0 :         return py_pvReserved2;
   14875             : }
   14876             : 
   14877           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_pvReserved2(PyObject *py_obj, PyObject *value, void *closure)
   14878             : {
   14879           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14880           0 :         if (value == NULL) {
   14881           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pvReserved2");
   14882           0 :                 return -1;
   14883             :         }
   14884             :         {
   14885           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->pvReserved2));
   14886           0 :                 if (PyLong_Check(value)) {
   14887           0 :                         unsigned long long test_var;
   14888           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   14889           0 :                         if (PyErr_Occurred() != NULL) {
   14890           0 :                                 return -1;
   14891             :                         }
   14892           0 :                         if (test_var > uint_max) {
   14893           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   14894             :                                   PyLong_Type.tp_name, uint_max, test_var);
   14895           0 :                                 return -1;
   14896             :                         }
   14897           0 :                         object->pvReserved2 = test_var;
   14898             :                 } else {
   14899           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   14900             :                           PyLong_Type.tp_name);
   14901           0 :                         return -1;
   14902             :                 }
   14903             :         }
   14904           0 :         return 0;
   14905             : }
   14906             : 
   14907           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_pvReserved3(PyObject *obj, void *closure)
   14908             : {
   14909           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   14910           0 :         PyObject *py_pvReserved3;
   14911           0 :         py_pvReserved3 = PyLong_FromUnsignedLongLong((uint32_t)(object->pvReserved3));
   14912           0 :         return py_pvReserved3;
   14913             : }
   14914             : 
   14915           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_pvReserved3(PyObject *py_obj, PyObject *value, void *closure)
   14916             : {
   14917           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14918           0 :         if (value == NULL) {
   14919           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pvReserved3");
   14920           0 :                 return -1;
   14921             :         }
   14922             :         {
   14923           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->pvReserved3));
   14924           0 :                 if (PyLong_Check(value)) {
   14925           0 :                         unsigned long long test_var;
   14926           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   14927           0 :                         if (PyErr_Occurred() != NULL) {
   14928           0 :                                 return -1;
   14929             :                         }
   14930           0 :                         if (test_var > uint_max) {
   14931           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   14932             :                                   PyLong_Type.tp_name, uint_max, test_var);
   14933           0 :                                 return -1;
   14934             :                         }
   14935           0 :                         object->pvReserved3 = test_var;
   14936             :                 } else {
   14937           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   14938             :                           PyLong_Type.tp_name);
   14939           0 :                         return -1;
   14940             :                 }
   14941             :         }
   14942           0 :         return 0;
   14943             : }
   14944             : 
   14945           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_get_pvReserved4(PyObject *obj, void *closure)
   14946             : {
   14947           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(obj);
   14948           0 :         PyObject *py_pvReserved4;
   14949           0 :         py_pvReserved4 = PyLong_FromUnsignedLongLong((uint32_t)(object->pvReserved4));
   14950           0 :         return py_pvReserved4;
   14951             : }
   14952             : 
   14953           0 : static int py_DNS_RPC_ZONE_INFO_W2K_set_pvReserved4(PyObject *py_obj, PyObject *value, void *closure)
   14954             : {
   14955           0 :         struct DNS_RPC_ZONE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   14956           0 :         if (value == NULL) {
   14957           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pvReserved4");
   14958           0 :                 return -1;
   14959             :         }
   14960             :         {
   14961           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->pvReserved4));
   14962           0 :                 if (PyLong_Check(value)) {
   14963           0 :                         unsigned long long test_var;
   14964           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   14965           0 :                         if (PyErr_Occurred() != NULL) {
   14966           0 :                                 return -1;
   14967             :                         }
   14968           0 :                         if (test_var > uint_max) {
   14969           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   14970             :                                   PyLong_Type.tp_name, uint_max, test_var);
   14971           0 :                                 return -1;
   14972             :                         }
   14973           0 :                         object->pvReserved4 = test_var;
   14974             :                 } else {
   14975           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   14976             :                           PyLong_Type.tp_name);
   14977           0 :                         return -1;
   14978             :                 }
   14979             :         }
   14980           0 :         return 0;
   14981             : }
   14982             : 
   14983             : static PyGetSetDef py_DNS_RPC_ZONE_INFO_W2K_getsetters[] = {
   14984             :         {
   14985             :                 .name = discard_const_p(char, "pszZoneName"),
   14986             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_pszZoneName,
   14987             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_pszZoneName,
   14988             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   14989             :         },
   14990             :         {
   14991             :                 .name = discard_const_p(char, "dwZoneType"),
   14992             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_dwZoneType,
   14993             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_dwZoneType,
   14994             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   14995             :         },
   14996             :         {
   14997             :                 .name = discard_const_p(char, "fReverse"),
   14998             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_fReverse,
   14999             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_fReverse,
   15000             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   15001             :         },
   15002             :         {
   15003             :                 .name = discard_const_p(char, "fAllowUpdate"),
   15004             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_fAllowUpdate,
   15005             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_fAllowUpdate,
   15006             :                 .doc = discard_const_p(char, "PIDL-generated element of base type dns_zone_update")
   15007             :         },
   15008             :         {
   15009             :                 .name = discard_const_p(char, "fPaused"),
   15010             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_fPaused,
   15011             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_fPaused,
   15012             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   15013             :         },
   15014             :         {
   15015             :                 .name = discard_const_p(char, "fShutdown"),
   15016             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_fShutdown,
   15017             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_fShutdown,
   15018             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   15019             :         },
   15020             :         {
   15021             :                 .name = discard_const_p(char, "fAutoCreated"),
   15022             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_fAutoCreated,
   15023             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_fAutoCreated,
   15024             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   15025             :         },
   15026             :         {
   15027             :                 .name = discard_const_p(char, "fUseDatabase"),
   15028             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_fUseDatabase,
   15029             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_fUseDatabase,
   15030             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   15031             :         },
   15032             :         {
   15033             :                 .name = discard_const_p(char, "pszDataFile"),
   15034             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_pszDataFile,
   15035             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_pszDataFile,
   15036             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   15037             :         },
   15038             :         {
   15039             :                 .name = discard_const_p(char, "aipMasters"),
   15040             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_aipMasters,
   15041             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_aipMasters,
   15042             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
   15043             :         },
   15044             :         {
   15045             :                 .name = discard_const_p(char, "fSecureSecondaries"),
   15046             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_fSecureSecondaries,
   15047             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_fSecureSecondaries,
   15048             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ZONE_SECONDARY_SECURITY")
   15049             :         },
   15050             :         {
   15051             :                 .name = discard_const_p(char, "fNotifyLevel"),
   15052             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_fNotifyLevel,
   15053             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_fNotifyLevel,
   15054             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ZONE_NOTIFY_LEVEL")
   15055             :         },
   15056             :         {
   15057             :                 .name = discard_const_p(char, "aipSecondaries"),
   15058             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_aipSecondaries,
   15059             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_aipSecondaries,
   15060             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
   15061             :         },
   15062             :         {
   15063             :                 .name = discard_const_p(char, "aipNotify"),
   15064             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_aipNotify,
   15065             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_aipNotify,
   15066             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
   15067             :         },
   15068             :         {
   15069             :                 .name = discard_const_p(char, "fUseWins"),
   15070             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_fUseWins,
   15071             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_fUseWins,
   15072             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   15073             :         },
   15074             :         {
   15075             :                 .name = discard_const_p(char, "fUseNbstat"),
   15076             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_fUseNbstat,
   15077             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_fUseNbstat,
   15078             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   15079             :         },
   15080             :         {
   15081             :                 .name = discard_const_p(char, "fAging"),
   15082             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_fAging,
   15083             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_fAging,
   15084             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   15085             :         },
   15086             :         {
   15087             :                 .name = discard_const_p(char, "dwNoRefreshInterval"),
   15088             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_dwNoRefreshInterval,
   15089             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_dwNoRefreshInterval,
   15090             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   15091             :         },
   15092             :         {
   15093             :                 .name = discard_const_p(char, "dwRefreshInterval"),
   15094             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_dwRefreshInterval,
   15095             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_dwRefreshInterval,
   15096             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   15097             :         },
   15098             :         {
   15099             :                 .name = discard_const_p(char, "dwAvailForScavengeTime"),
   15100             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_dwAvailForScavengeTime,
   15101             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_dwAvailForScavengeTime,
   15102             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   15103             :         },
   15104             :         {
   15105             :                 .name = discard_const_p(char, "aipScavengeServers"),
   15106             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_aipScavengeServers,
   15107             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_aipScavengeServers,
   15108             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
   15109             :         },
   15110             :         {
   15111             :                 .name = discard_const_p(char, "pvReserved1"),
   15112             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_pvReserved1,
   15113             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_pvReserved1,
   15114             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   15115             :         },
   15116             :         {
   15117             :                 .name = discard_const_p(char, "pvReserved2"),
   15118             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_pvReserved2,
   15119             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_pvReserved2,
   15120             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   15121             :         },
   15122             :         {
   15123             :                 .name = discard_const_p(char, "pvReserved3"),
   15124             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_pvReserved3,
   15125             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_pvReserved3,
   15126             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   15127             :         },
   15128             :         {
   15129             :                 .name = discard_const_p(char, "pvReserved4"),
   15130             :                 .get = py_DNS_RPC_ZONE_INFO_W2K_get_pvReserved4,
   15131             :                 .set = py_DNS_RPC_ZONE_INFO_W2K_set_pvReserved4,
   15132             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   15133             :         },
   15134             :         { .name = NULL }
   15135             : };
   15136             : 
   15137           0 : static PyObject *py_DNS_RPC_ZONE_INFO_W2K_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   15138             : {
   15139           0 :         return pytalloc_new(struct DNS_RPC_ZONE_INFO_W2K, type);
   15140             : }
   15141             : 
   15142             : 
   15143             : static PyTypeObject DNS_RPC_ZONE_INFO_W2K_Type = {
   15144             :         PyVarObject_HEAD_INIT(NULL, 0)
   15145             :         .tp_name = "dnsserver.DNS_RPC_ZONE_INFO_W2K",
   15146             :         .tp_getset = py_DNS_RPC_ZONE_INFO_W2K_getsetters,
   15147             :         .tp_methods = NULL,
   15148             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   15149             :         .tp_new = py_DNS_RPC_ZONE_INFO_W2K_new,
   15150             : };
   15151             : 
   15152             : 
   15153           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_dwRpcStructureVersion(PyObject *obj, void *closure)
   15154             : {
   15155           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   15156           0 :         PyObject *py_dwRpcStructureVersion;
   15157           0 :         py_dwRpcStructureVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcStructureVersion));
   15158           0 :         return py_dwRpcStructureVersion;
   15159             : }
   15160             : 
   15161           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_dwRpcStructureVersion(PyObject *py_obj, PyObject *value, void *closure)
   15162             : {
   15163           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   15164           0 :         if (value == NULL) {
   15165           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcStructureVersion");
   15166           0 :                 return -1;
   15167             :         }
   15168             :         {
   15169           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcStructureVersion));
   15170           0 :                 if (PyLong_Check(value)) {
   15171           0 :                         unsigned long long test_var;
   15172           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   15173           0 :                         if (PyErr_Occurred() != NULL) {
   15174           0 :                                 return -1;
   15175             :                         }
   15176           0 :                         if (test_var > uint_max) {
   15177           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   15178             :                                   PyLong_Type.tp_name, uint_max, test_var);
   15179           0 :                                 return -1;
   15180             :                         }
   15181           0 :                         object->dwRpcStructureVersion = test_var;
   15182             :                 } else {
   15183           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   15184             :                           PyLong_Type.tp_name);
   15185           0 :                         return -1;
   15186             :                 }
   15187             :         }
   15188           0 :         return 0;
   15189             : }
   15190             : 
   15191           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_dwReserved0(PyObject *obj, void *closure)
   15192             : {
   15193           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   15194           0 :         PyObject *py_dwReserved0;
   15195           0 :         py_dwReserved0 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved0));
   15196           0 :         return py_dwReserved0;
   15197             : }
   15198             : 
   15199           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_dwReserved0(PyObject *py_obj, PyObject *value, void *closure)
   15200             : {
   15201           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   15202           0 :         if (value == NULL) {
   15203           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved0");
   15204           0 :                 return -1;
   15205             :         }
   15206             :         {
   15207           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved0));
   15208           0 :                 if (PyLong_Check(value)) {
   15209           0 :                         unsigned long long test_var;
   15210           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   15211           0 :                         if (PyErr_Occurred() != NULL) {
   15212           0 :                                 return -1;
   15213             :                         }
   15214           0 :                         if (test_var > uint_max) {
   15215           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   15216             :                                   PyLong_Type.tp_name, uint_max, test_var);
   15217           0 :                                 return -1;
   15218             :                         }
   15219           0 :                         object->dwReserved0 = test_var;
   15220             :                 } else {
   15221           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   15222             :                           PyLong_Type.tp_name);
   15223           0 :                         return -1;
   15224             :                 }
   15225             :         }
   15226           0 :         return 0;
   15227             : }
   15228             : 
   15229           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_pszZoneName(PyObject *obj, void *closure)
   15230             : {
   15231           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   15232           0 :         PyObject *py_pszZoneName;
   15233           0 :         if (object->pszZoneName == NULL) {
   15234           0 :                 Py_RETURN_NONE;
   15235             :         }
   15236           0 :         if (object->pszZoneName == NULL) {
   15237           0 :                 py_pszZoneName = Py_None;
   15238           0 :                 Py_INCREF(py_pszZoneName);
   15239             :         } else {
   15240           0 :                 if (object->pszZoneName == NULL) {
   15241           0 :                         py_pszZoneName = Py_None;
   15242           0 :                         Py_INCREF(py_pszZoneName);
   15243             :                 } else {
   15244           0 :                         py_pszZoneName = PyUnicode_Decode(object->pszZoneName, strlen(object->pszZoneName), "utf-8", "ignore");
   15245             :                 }
   15246             :         }
   15247           0 :         return py_pszZoneName;
   15248             : }
   15249             : 
   15250           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_pszZoneName(PyObject *py_obj, PyObject *value, void *closure)
   15251             : {
   15252           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   15253           0 :         if (value == NULL) {
   15254           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszZoneName");
   15255           0 :                 return -1;
   15256             :         }
   15257           0 :         if (value == Py_None) {
   15258           0 :                 object->pszZoneName = NULL;
   15259             :         } else {
   15260           0 :                 object->pszZoneName = NULL;
   15261             :                 {
   15262           0 :                         const char *test_str;
   15263           0 :                         const char *talloc_str;
   15264           0 :                         PyObject *unicode = NULL;
   15265           0 :                         if (PyUnicode_Check(value)) {
   15266           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   15267           0 :                                 if (unicode == NULL) {
   15268           0 :                                         return -1;
   15269             :                                 }
   15270           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   15271           0 :                         } else if (PyBytes_Check(value)) {
   15272           0 :                                 test_str = PyBytes_AS_STRING(value);
   15273             :                         } else {
   15274           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   15275           0 :                                 return -1;
   15276             :                         }
   15277           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   15278           0 :                         if (unicode != NULL) {
   15279           0 :                                 Py_DECREF(unicode);
   15280             :                         }
   15281           0 :                         if (talloc_str == NULL) {
   15282           0 :                                 PyErr_NoMemory();
   15283           0 :                                 return -1;
   15284             :                         }
   15285           0 :                         object->pszZoneName = talloc_str;
   15286             :                 }
   15287             :         }
   15288           0 :         return 0;
   15289             : }
   15290             : 
   15291           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_dwZoneType(PyObject *obj, void *closure)
   15292             : {
   15293           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   15294           0 :         PyObject *py_dwZoneType;
   15295           0 :         py_dwZoneType = PyLong_FromUnsignedLongLong((uint32_t)(object->dwZoneType));
   15296           0 :         return py_dwZoneType;
   15297             : }
   15298             : 
   15299           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_dwZoneType(PyObject *py_obj, PyObject *value, void *closure)
   15300             : {
   15301           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   15302           0 :         if (value == NULL) {
   15303           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwZoneType");
   15304           0 :                 return -1;
   15305             :         }
   15306             :         {
   15307           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwZoneType));
   15308           0 :                 if (PyLong_Check(value)) {
   15309           0 :                         unsigned long long test_var;
   15310           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   15311           0 :                         if (PyErr_Occurred() != NULL) {
   15312           0 :                                 return -1;
   15313             :                         }
   15314           0 :                         if (test_var > uint_max) {
   15315           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   15316             :                                   PyLong_Type.tp_name, uint_max, test_var);
   15317           0 :                                 return -1;
   15318             :                         }
   15319           0 :                         object->dwZoneType = test_var;
   15320             :                 } else {
   15321           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   15322             :                           PyLong_Type.tp_name);
   15323           0 :                         return -1;
   15324             :                 }
   15325             :         }
   15326           0 :         return 0;
   15327             : }
   15328             : 
   15329           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_fReverse(PyObject *obj, void *closure)
   15330             : {
   15331           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   15332           0 :         PyObject *py_fReverse;
   15333           0 :         py_fReverse = PyLong_FromUnsignedLongLong((uint32_t)(object->fReverse));
   15334           0 :         return py_fReverse;
   15335             : }
   15336             : 
   15337           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_fReverse(PyObject *py_obj, PyObject *value, void *closure)
   15338             : {
   15339           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   15340           0 :         if (value == NULL) {
   15341           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fReverse");
   15342           0 :                 return -1;
   15343             :         }
   15344             :         {
   15345           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fReverse));
   15346           0 :                 if (PyLong_Check(value)) {
   15347           0 :                         unsigned long long test_var;
   15348           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   15349           0 :                         if (PyErr_Occurred() != NULL) {
   15350           0 :                                 return -1;
   15351             :                         }
   15352           0 :                         if (test_var > uint_max) {
   15353           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   15354             :                                   PyLong_Type.tp_name, uint_max, test_var);
   15355           0 :                                 return -1;
   15356             :                         }
   15357           0 :                         object->fReverse = test_var;
   15358             :                 } else {
   15359           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   15360             :                           PyLong_Type.tp_name);
   15361           0 :                         return -1;
   15362             :                 }
   15363             :         }
   15364           0 :         return 0;
   15365             : }
   15366             : 
   15367           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_fAllowUpdate(PyObject *obj, void *closure)
   15368             : {
   15369           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   15370           0 :         PyObject *py_fAllowUpdate;
   15371           0 :         py_fAllowUpdate = PyLong_FromLong((uint16_t)(object->fAllowUpdate));
   15372           0 :         return py_fAllowUpdate;
   15373             : }
   15374             : 
   15375           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_fAllowUpdate(PyObject *py_obj, PyObject *value, void *closure)
   15376             : {
   15377           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   15378           0 :         if (value == NULL) {
   15379           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAllowUpdate");
   15380           0 :                 return -1;
   15381             :         }
   15382             :         {
   15383           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAllowUpdate));
   15384           0 :                 if (PyLong_Check(value)) {
   15385           0 :                         unsigned long long test_var;
   15386           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   15387           0 :                         if (PyErr_Occurred() != NULL) {
   15388           0 :                                 return -1;
   15389             :                         }
   15390           0 :                         if (test_var > uint_max) {
   15391           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   15392             :                                   PyLong_Type.tp_name, uint_max, test_var);
   15393           0 :                                 return -1;
   15394             :                         }
   15395           0 :                         object->fAllowUpdate = test_var;
   15396             :                 } else {
   15397           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   15398             :                           PyLong_Type.tp_name);
   15399           0 :                         return -1;
   15400             :                 }
   15401             :         }
   15402           0 :         return 0;
   15403             : }
   15404             : 
   15405           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_fPaused(PyObject *obj, void *closure)
   15406             : {
   15407           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   15408           0 :         PyObject *py_fPaused;
   15409           0 :         py_fPaused = PyLong_FromUnsignedLongLong((uint32_t)(object->fPaused));
   15410           0 :         return py_fPaused;
   15411             : }
   15412             : 
   15413           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_fPaused(PyObject *py_obj, PyObject *value, void *closure)
   15414             : {
   15415           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   15416           0 :         if (value == NULL) {
   15417           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fPaused");
   15418           0 :                 return -1;
   15419             :         }
   15420             :         {
   15421           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fPaused));
   15422           0 :                 if (PyLong_Check(value)) {
   15423           0 :                         unsigned long long test_var;
   15424           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   15425           0 :                         if (PyErr_Occurred() != NULL) {
   15426           0 :                                 return -1;
   15427             :                         }
   15428           0 :                         if (test_var > uint_max) {
   15429           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   15430             :                                   PyLong_Type.tp_name, uint_max, test_var);
   15431           0 :                                 return -1;
   15432             :                         }
   15433           0 :                         object->fPaused = test_var;
   15434             :                 } else {
   15435           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   15436             :                           PyLong_Type.tp_name);
   15437           0 :                         return -1;
   15438             :                 }
   15439             :         }
   15440           0 :         return 0;
   15441             : }
   15442             : 
   15443           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_fShutdown(PyObject *obj, void *closure)
   15444             : {
   15445           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   15446           0 :         PyObject *py_fShutdown;
   15447           0 :         py_fShutdown = PyLong_FromUnsignedLongLong((uint32_t)(object->fShutdown));
   15448           0 :         return py_fShutdown;
   15449             : }
   15450             : 
   15451           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_fShutdown(PyObject *py_obj, PyObject *value, void *closure)
   15452             : {
   15453           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   15454           0 :         if (value == NULL) {
   15455           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fShutdown");
   15456           0 :                 return -1;
   15457             :         }
   15458             :         {
   15459           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fShutdown));
   15460           0 :                 if (PyLong_Check(value)) {
   15461           0 :                         unsigned long long test_var;
   15462           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   15463           0 :                         if (PyErr_Occurred() != NULL) {
   15464           0 :                                 return -1;
   15465             :                         }
   15466           0 :                         if (test_var > uint_max) {
   15467           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   15468             :                                   PyLong_Type.tp_name, uint_max, test_var);
   15469           0 :                                 return -1;
   15470             :                         }
   15471           0 :                         object->fShutdown = test_var;
   15472             :                 } else {
   15473           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   15474             :                           PyLong_Type.tp_name);
   15475           0 :                         return -1;
   15476             :                 }
   15477             :         }
   15478           0 :         return 0;
   15479             : }
   15480             : 
   15481           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_fAutoCreated(PyObject *obj, void *closure)
   15482             : {
   15483           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   15484           0 :         PyObject *py_fAutoCreated;
   15485           0 :         py_fAutoCreated = PyLong_FromUnsignedLongLong((uint32_t)(object->fAutoCreated));
   15486           0 :         return py_fAutoCreated;
   15487             : }
   15488             : 
   15489           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_fAutoCreated(PyObject *py_obj, PyObject *value, void *closure)
   15490             : {
   15491           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   15492           0 :         if (value == NULL) {
   15493           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAutoCreated");
   15494           0 :                 return -1;
   15495             :         }
   15496             :         {
   15497           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAutoCreated));
   15498           0 :                 if (PyLong_Check(value)) {
   15499           0 :                         unsigned long long test_var;
   15500           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   15501           0 :                         if (PyErr_Occurred() != NULL) {
   15502           0 :                                 return -1;
   15503             :                         }
   15504           0 :                         if (test_var > uint_max) {
   15505           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   15506             :                                   PyLong_Type.tp_name, uint_max, test_var);
   15507           0 :                                 return -1;
   15508             :                         }
   15509           0 :                         object->fAutoCreated = test_var;
   15510             :                 } else {
   15511           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   15512             :                           PyLong_Type.tp_name);
   15513           0 :                         return -1;
   15514             :                 }
   15515             :         }
   15516           0 :         return 0;
   15517             : }
   15518             : 
   15519           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_fUseDatabase(PyObject *obj, void *closure)
   15520             : {
   15521           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   15522           0 :         PyObject *py_fUseDatabase;
   15523           0 :         py_fUseDatabase = PyLong_FromUnsignedLongLong((uint32_t)(object->fUseDatabase));
   15524           0 :         return py_fUseDatabase;
   15525             : }
   15526             : 
   15527           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_fUseDatabase(PyObject *py_obj, PyObject *value, void *closure)
   15528             : {
   15529           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   15530           0 :         if (value == NULL) {
   15531           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fUseDatabase");
   15532           0 :                 return -1;
   15533             :         }
   15534             :         {
   15535           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fUseDatabase));
   15536           0 :                 if (PyLong_Check(value)) {
   15537           0 :                         unsigned long long test_var;
   15538           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   15539           0 :                         if (PyErr_Occurred() != NULL) {
   15540           0 :                                 return -1;
   15541             :                         }
   15542           0 :                         if (test_var > uint_max) {
   15543           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   15544             :                                   PyLong_Type.tp_name, uint_max, test_var);
   15545           0 :                                 return -1;
   15546             :                         }
   15547           0 :                         object->fUseDatabase = test_var;
   15548             :                 } else {
   15549           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   15550             :                           PyLong_Type.tp_name);
   15551           0 :                         return -1;
   15552             :                 }
   15553             :         }
   15554           0 :         return 0;
   15555             : }
   15556             : 
   15557           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_pszDataFile(PyObject *obj, void *closure)
   15558             : {
   15559           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   15560           0 :         PyObject *py_pszDataFile;
   15561           0 :         if (object->pszDataFile == NULL) {
   15562           0 :                 Py_RETURN_NONE;
   15563             :         }
   15564           0 :         if (object->pszDataFile == NULL) {
   15565           0 :                 py_pszDataFile = Py_None;
   15566           0 :                 Py_INCREF(py_pszDataFile);
   15567             :         } else {
   15568           0 :                 if (object->pszDataFile == NULL) {
   15569           0 :                         py_pszDataFile = Py_None;
   15570           0 :                         Py_INCREF(py_pszDataFile);
   15571             :                 } else {
   15572           0 :                         py_pszDataFile = PyUnicode_Decode(object->pszDataFile, strlen(object->pszDataFile), "utf-8", "ignore");
   15573             :                 }
   15574             :         }
   15575           0 :         return py_pszDataFile;
   15576             : }
   15577             : 
   15578           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_pszDataFile(PyObject *py_obj, PyObject *value, void *closure)
   15579             : {
   15580           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   15581           0 :         if (value == NULL) {
   15582           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszDataFile");
   15583           0 :                 return -1;
   15584             :         }
   15585           0 :         if (value == Py_None) {
   15586           0 :                 object->pszDataFile = NULL;
   15587             :         } else {
   15588           0 :                 object->pszDataFile = NULL;
   15589             :                 {
   15590           0 :                         const char *test_str;
   15591           0 :                         const char *talloc_str;
   15592           0 :                         PyObject *unicode = NULL;
   15593           0 :                         if (PyUnicode_Check(value)) {
   15594           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   15595           0 :                                 if (unicode == NULL) {
   15596           0 :                                         return -1;
   15597             :                                 }
   15598           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   15599           0 :                         } else if (PyBytes_Check(value)) {
   15600           0 :                                 test_str = PyBytes_AS_STRING(value);
   15601             :                         } else {
   15602           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   15603           0 :                                 return -1;
   15604             :                         }
   15605           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   15606           0 :                         if (unicode != NULL) {
   15607           0 :                                 Py_DECREF(unicode);
   15608             :                         }
   15609           0 :                         if (talloc_str == NULL) {
   15610           0 :                                 PyErr_NoMemory();
   15611           0 :                                 return -1;
   15612             :                         }
   15613           0 :                         object->pszDataFile = talloc_str;
   15614             :                 }
   15615             :         }
   15616           0 :         return 0;
   15617             : }
   15618             : 
   15619           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_aipMasters(PyObject *obj, void *closure)
   15620             : {
   15621           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   15622           0 :         PyObject *py_aipMasters;
   15623           0 :         if (object->aipMasters == NULL) {
   15624           0 :                 Py_RETURN_NONE;
   15625             :         }
   15626           0 :         if (object->aipMasters == NULL) {
   15627           0 :                 py_aipMasters = Py_None;
   15628           0 :                 Py_INCREF(py_aipMasters);
   15629             :         } else {
   15630           0 :                 py_aipMasters = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipMasters, object->aipMasters);
   15631             :         }
   15632           0 :         return py_aipMasters;
   15633             : }
   15634             : 
   15635           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_aipMasters(PyObject *py_obj, PyObject *value, void *closure)
   15636             : {
   15637           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   15638           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipMasters));
   15639           0 :         if (value == NULL) {
   15640           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipMasters");
   15641           0 :                 return -1;
   15642             :         }
   15643           0 :         if (value == Py_None) {
   15644           0 :                 object->aipMasters = NULL;
   15645             :         } else {
   15646           0 :                 object->aipMasters = NULL;
   15647           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
   15648           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   15649           0 :                         PyErr_NoMemory();
   15650           0 :                         return -1;
   15651             :                 }
   15652           0 :                 object->aipMasters = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
   15653             :         }
   15654           0 :         return 0;
   15655             : }
   15656             : 
   15657           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_fSecureSecondaries(PyObject *obj, void *closure)
   15658             : {
   15659           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   15660           0 :         PyObject *py_fSecureSecondaries;
   15661           0 :         py_fSecureSecondaries = PyLong_FromUnsignedLongLong((uint32_t)(object->fSecureSecondaries));
   15662           0 :         return py_fSecureSecondaries;
   15663             : }
   15664             : 
   15665           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_fSecureSecondaries(PyObject *py_obj, PyObject *value, void *closure)
   15666             : {
   15667           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   15668           0 :         if (value == NULL) {
   15669           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fSecureSecondaries");
   15670           0 :                 return -1;
   15671             :         }
   15672             :         {
   15673           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fSecureSecondaries));
   15674           0 :                 if (PyLong_Check(value)) {
   15675           0 :                         unsigned long long test_var;
   15676           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   15677           0 :                         if (PyErr_Occurred() != NULL) {
   15678           0 :                                 return -1;
   15679             :                         }
   15680           0 :                         if (test_var > uint_max) {
   15681           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   15682             :                                   PyLong_Type.tp_name, uint_max, test_var);
   15683           0 :                                 return -1;
   15684             :                         }
   15685           0 :                         object->fSecureSecondaries = test_var;
   15686             :                 } else {
   15687           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   15688             :                           PyLong_Type.tp_name);
   15689           0 :                         return -1;
   15690             :                 }
   15691             :         }
   15692           0 :         return 0;
   15693             : }
   15694             : 
   15695           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_fNotifyLevel(PyObject *obj, void *closure)
   15696             : {
   15697           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   15698           0 :         PyObject *py_fNotifyLevel;
   15699           0 :         py_fNotifyLevel = PyLong_FromUnsignedLongLong((uint32_t)(object->fNotifyLevel));
   15700           0 :         return py_fNotifyLevel;
   15701             : }
   15702             : 
   15703           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_fNotifyLevel(PyObject *py_obj, PyObject *value, void *closure)
   15704             : {
   15705           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   15706           0 :         if (value == NULL) {
   15707           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fNotifyLevel");
   15708           0 :                 return -1;
   15709             :         }
   15710             :         {
   15711           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fNotifyLevel));
   15712           0 :                 if (PyLong_Check(value)) {
   15713           0 :                         unsigned long long test_var;
   15714           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   15715           0 :                         if (PyErr_Occurred() != NULL) {
   15716           0 :                                 return -1;
   15717             :                         }
   15718           0 :                         if (test_var > uint_max) {
   15719           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   15720             :                                   PyLong_Type.tp_name, uint_max, test_var);
   15721           0 :                                 return -1;
   15722             :                         }
   15723           0 :                         object->fNotifyLevel = test_var;
   15724             :                 } else {
   15725           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   15726             :                           PyLong_Type.tp_name);
   15727           0 :                         return -1;
   15728             :                 }
   15729             :         }
   15730           0 :         return 0;
   15731             : }
   15732             : 
   15733           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_aipSecondaries(PyObject *obj, void *closure)
   15734             : {
   15735           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   15736           0 :         PyObject *py_aipSecondaries;
   15737           0 :         if (object->aipSecondaries == NULL) {
   15738           0 :                 Py_RETURN_NONE;
   15739             :         }
   15740           0 :         if (object->aipSecondaries == NULL) {
   15741           0 :                 py_aipSecondaries = Py_None;
   15742           0 :                 Py_INCREF(py_aipSecondaries);
   15743             :         } else {
   15744           0 :                 py_aipSecondaries = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipSecondaries, object->aipSecondaries);
   15745             :         }
   15746           0 :         return py_aipSecondaries;
   15747             : }
   15748             : 
   15749           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_aipSecondaries(PyObject *py_obj, PyObject *value, void *closure)
   15750             : {
   15751           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   15752           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipSecondaries));
   15753           0 :         if (value == NULL) {
   15754           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipSecondaries");
   15755           0 :                 return -1;
   15756             :         }
   15757           0 :         if (value == Py_None) {
   15758           0 :                 object->aipSecondaries = NULL;
   15759             :         } else {
   15760           0 :                 object->aipSecondaries = NULL;
   15761           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
   15762           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   15763           0 :                         PyErr_NoMemory();
   15764           0 :                         return -1;
   15765             :                 }
   15766           0 :                 object->aipSecondaries = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
   15767             :         }
   15768           0 :         return 0;
   15769             : }
   15770             : 
   15771           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_aipNotify(PyObject *obj, void *closure)
   15772             : {
   15773           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   15774           0 :         PyObject *py_aipNotify;
   15775           0 :         if (object->aipNotify == NULL) {
   15776           0 :                 Py_RETURN_NONE;
   15777             :         }
   15778           0 :         if (object->aipNotify == NULL) {
   15779           0 :                 py_aipNotify = Py_None;
   15780           0 :                 Py_INCREF(py_aipNotify);
   15781             :         } else {
   15782           0 :                 py_aipNotify = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipNotify, object->aipNotify);
   15783             :         }
   15784           0 :         return py_aipNotify;
   15785             : }
   15786             : 
   15787           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_aipNotify(PyObject *py_obj, PyObject *value, void *closure)
   15788             : {
   15789           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   15790           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipNotify));
   15791           0 :         if (value == NULL) {
   15792           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipNotify");
   15793           0 :                 return -1;
   15794             :         }
   15795           0 :         if (value == Py_None) {
   15796           0 :                 object->aipNotify = NULL;
   15797             :         } else {
   15798           0 :                 object->aipNotify = NULL;
   15799           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
   15800           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   15801           0 :                         PyErr_NoMemory();
   15802           0 :                         return -1;
   15803             :                 }
   15804           0 :                 object->aipNotify = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
   15805             :         }
   15806           0 :         return 0;
   15807             : }
   15808             : 
   15809           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_fUseWins(PyObject *obj, void *closure)
   15810             : {
   15811           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   15812           0 :         PyObject *py_fUseWins;
   15813           0 :         py_fUseWins = PyLong_FromUnsignedLongLong((uint32_t)(object->fUseWins));
   15814           0 :         return py_fUseWins;
   15815             : }
   15816             : 
   15817           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_fUseWins(PyObject *py_obj, PyObject *value, void *closure)
   15818             : {
   15819           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   15820           0 :         if (value == NULL) {
   15821           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fUseWins");
   15822           0 :                 return -1;
   15823             :         }
   15824             :         {
   15825           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fUseWins));
   15826           0 :                 if (PyLong_Check(value)) {
   15827           0 :                         unsigned long long test_var;
   15828           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   15829           0 :                         if (PyErr_Occurred() != NULL) {
   15830           0 :                                 return -1;
   15831             :                         }
   15832           0 :                         if (test_var > uint_max) {
   15833           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   15834             :                                   PyLong_Type.tp_name, uint_max, test_var);
   15835           0 :                                 return -1;
   15836             :                         }
   15837           0 :                         object->fUseWins = test_var;
   15838             :                 } else {
   15839           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   15840             :                           PyLong_Type.tp_name);
   15841           0 :                         return -1;
   15842             :                 }
   15843             :         }
   15844           0 :         return 0;
   15845             : }
   15846             : 
   15847           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_fUseNbstat(PyObject *obj, void *closure)
   15848             : {
   15849           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   15850           0 :         PyObject *py_fUseNbstat;
   15851           0 :         py_fUseNbstat = PyLong_FromUnsignedLongLong((uint32_t)(object->fUseNbstat));
   15852           0 :         return py_fUseNbstat;
   15853             : }
   15854             : 
   15855           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_fUseNbstat(PyObject *py_obj, PyObject *value, void *closure)
   15856             : {
   15857           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   15858           0 :         if (value == NULL) {
   15859           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fUseNbstat");
   15860           0 :                 return -1;
   15861             :         }
   15862             :         {
   15863           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fUseNbstat));
   15864           0 :                 if (PyLong_Check(value)) {
   15865           0 :                         unsigned long long test_var;
   15866           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   15867           0 :                         if (PyErr_Occurred() != NULL) {
   15868           0 :                                 return -1;
   15869             :                         }
   15870           0 :                         if (test_var > uint_max) {
   15871           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   15872             :                                   PyLong_Type.tp_name, uint_max, test_var);
   15873           0 :                                 return -1;
   15874             :                         }
   15875           0 :                         object->fUseNbstat = test_var;
   15876             :                 } else {
   15877           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   15878             :                           PyLong_Type.tp_name);
   15879           0 :                         return -1;
   15880             :                 }
   15881             :         }
   15882           0 :         return 0;
   15883             : }
   15884             : 
   15885           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_fAging(PyObject *obj, void *closure)
   15886             : {
   15887           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   15888           0 :         PyObject *py_fAging;
   15889           0 :         py_fAging = PyLong_FromUnsignedLongLong((uint32_t)(object->fAging));
   15890           0 :         return py_fAging;
   15891             : }
   15892             : 
   15893           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_fAging(PyObject *py_obj, PyObject *value, void *closure)
   15894             : {
   15895           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   15896           0 :         if (value == NULL) {
   15897           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAging");
   15898           0 :                 return -1;
   15899             :         }
   15900             :         {
   15901           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAging));
   15902           0 :                 if (PyLong_Check(value)) {
   15903           0 :                         unsigned long long test_var;
   15904           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   15905           0 :                         if (PyErr_Occurred() != NULL) {
   15906           0 :                                 return -1;
   15907             :                         }
   15908           0 :                         if (test_var > uint_max) {
   15909           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   15910             :                                   PyLong_Type.tp_name, uint_max, test_var);
   15911           0 :                                 return -1;
   15912             :                         }
   15913           0 :                         object->fAging = test_var;
   15914             :                 } else {
   15915           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   15916             :                           PyLong_Type.tp_name);
   15917           0 :                         return -1;
   15918             :                 }
   15919             :         }
   15920           0 :         return 0;
   15921             : }
   15922             : 
   15923           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_dwNoRefreshInterval(PyObject *obj, void *closure)
   15924             : {
   15925           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   15926           0 :         PyObject *py_dwNoRefreshInterval;
   15927           0 :         py_dwNoRefreshInterval = PyLong_FromUnsignedLongLong((uint32_t)(object->dwNoRefreshInterval));
   15928           0 :         return py_dwNoRefreshInterval;
   15929             : }
   15930             : 
   15931           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_dwNoRefreshInterval(PyObject *py_obj, PyObject *value, void *closure)
   15932             : {
   15933           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   15934           0 :         if (value == NULL) {
   15935           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwNoRefreshInterval");
   15936           0 :                 return -1;
   15937             :         }
   15938             :         {
   15939           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwNoRefreshInterval));
   15940           0 :                 if (PyLong_Check(value)) {
   15941           0 :                         unsigned long long test_var;
   15942           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   15943           0 :                         if (PyErr_Occurred() != NULL) {
   15944           0 :                                 return -1;
   15945             :                         }
   15946           0 :                         if (test_var > uint_max) {
   15947           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   15948             :                                   PyLong_Type.tp_name, uint_max, test_var);
   15949           0 :                                 return -1;
   15950             :                         }
   15951           0 :                         object->dwNoRefreshInterval = test_var;
   15952             :                 } else {
   15953           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   15954             :                           PyLong_Type.tp_name);
   15955           0 :                         return -1;
   15956             :                 }
   15957             :         }
   15958           0 :         return 0;
   15959             : }
   15960             : 
   15961           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_dwRefreshInterval(PyObject *obj, void *closure)
   15962             : {
   15963           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   15964           0 :         PyObject *py_dwRefreshInterval;
   15965           0 :         py_dwRefreshInterval = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRefreshInterval));
   15966           0 :         return py_dwRefreshInterval;
   15967             : }
   15968             : 
   15969           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_dwRefreshInterval(PyObject *py_obj, PyObject *value, void *closure)
   15970             : {
   15971           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   15972           0 :         if (value == NULL) {
   15973           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRefreshInterval");
   15974           0 :                 return -1;
   15975             :         }
   15976             :         {
   15977           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRefreshInterval));
   15978           0 :                 if (PyLong_Check(value)) {
   15979           0 :                         unsigned long long test_var;
   15980           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   15981           0 :                         if (PyErr_Occurred() != NULL) {
   15982           0 :                                 return -1;
   15983             :                         }
   15984           0 :                         if (test_var > uint_max) {
   15985           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   15986             :                                   PyLong_Type.tp_name, uint_max, test_var);
   15987           0 :                                 return -1;
   15988             :                         }
   15989           0 :                         object->dwRefreshInterval = test_var;
   15990             :                 } else {
   15991           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   15992             :                           PyLong_Type.tp_name);
   15993           0 :                         return -1;
   15994             :                 }
   15995             :         }
   15996           0 :         return 0;
   15997             : }
   15998             : 
   15999           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_dwAvailForScavengeTime(PyObject *obj, void *closure)
   16000             : {
   16001           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   16002           0 :         PyObject *py_dwAvailForScavengeTime;
   16003           0 :         py_dwAvailForScavengeTime = PyLong_FromUnsignedLongLong((uint32_t)(object->dwAvailForScavengeTime));
   16004           0 :         return py_dwAvailForScavengeTime;
   16005             : }
   16006             : 
   16007           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_dwAvailForScavengeTime(PyObject *py_obj, PyObject *value, void *closure)
   16008             : {
   16009           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   16010           0 :         if (value == NULL) {
   16011           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwAvailForScavengeTime");
   16012           0 :                 return -1;
   16013             :         }
   16014             :         {
   16015           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwAvailForScavengeTime));
   16016           0 :                 if (PyLong_Check(value)) {
   16017           0 :                         unsigned long long test_var;
   16018           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   16019           0 :                         if (PyErr_Occurred() != NULL) {
   16020           0 :                                 return -1;
   16021             :                         }
   16022           0 :                         if (test_var > uint_max) {
   16023           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   16024             :                                   PyLong_Type.tp_name, uint_max, test_var);
   16025           0 :                                 return -1;
   16026             :                         }
   16027           0 :                         object->dwAvailForScavengeTime = test_var;
   16028             :                 } else {
   16029           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   16030             :                           PyLong_Type.tp_name);
   16031           0 :                         return -1;
   16032             :                 }
   16033             :         }
   16034           0 :         return 0;
   16035             : }
   16036             : 
   16037           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_aipScavengeServers(PyObject *obj, void *closure)
   16038             : {
   16039           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   16040           0 :         PyObject *py_aipScavengeServers;
   16041           0 :         if (object->aipScavengeServers == NULL) {
   16042           0 :                 Py_RETURN_NONE;
   16043             :         }
   16044           0 :         if (object->aipScavengeServers == NULL) {
   16045           0 :                 py_aipScavengeServers = Py_None;
   16046           0 :                 Py_INCREF(py_aipScavengeServers);
   16047             :         } else {
   16048           0 :                 py_aipScavengeServers = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipScavengeServers, object->aipScavengeServers);
   16049             :         }
   16050           0 :         return py_aipScavengeServers;
   16051             : }
   16052             : 
   16053           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_aipScavengeServers(PyObject *py_obj, PyObject *value, void *closure)
   16054             : {
   16055           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   16056           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipScavengeServers));
   16057           0 :         if (value == NULL) {
   16058           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipScavengeServers");
   16059           0 :                 return -1;
   16060             :         }
   16061           0 :         if (value == Py_None) {
   16062           0 :                 object->aipScavengeServers = NULL;
   16063             :         } else {
   16064           0 :                 object->aipScavengeServers = NULL;
   16065           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
   16066           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   16067           0 :                         PyErr_NoMemory();
   16068           0 :                         return -1;
   16069             :                 }
   16070           0 :                 object->aipScavengeServers = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
   16071             :         }
   16072           0 :         return 0;
   16073             : }
   16074             : 
   16075           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_dwForwarderTimeout(PyObject *obj, void *closure)
   16076             : {
   16077           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   16078           0 :         PyObject *py_dwForwarderTimeout;
   16079           0 :         py_dwForwarderTimeout = PyLong_FromUnsignedLongLong((uint32_t)(object->dwForwarderTimeout));
   16080           0 :         return py_dwForwarderTimeout;
   16081             : }
   16082             : 
   16083           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_dwForwarderTimeout(PyObject *py_obj, PyObject *value, void *closure)
   16084             : {
   16085           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   16086           0 :         if (value == NULL) {
   16087           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwForwarderTimeout");
   16088           0 :                 return -1;
   16089             :         }
   16090             :         {
   16091           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwForwarderTimeout));
   16092           0 :                 if (PyLong_Check(value)) {
   16093           0 :                         unsigned long long test_var;
   16094           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   16095           0 :                         if (PyErr_Occurred() != NULL) {
   16096           0 :                                 return -1;
   16097             :                         }
   16098           0 :                         if (test_var > uint_max) {
   16099           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   16100             :                                   PyLong_Type.tp_name, uint_max, test_var);
   16101           0 :                                 return -1;
   16102             :                         }
   16103           0 :                         object->dwForwarderTimeout = test_var;
   16104             :                 } else {
   16105           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   16106             :                           PyLong_Type.tp_name);
   16107           0 :                         return -1;
   16108             :                 }
   16109             :         }
   16110           0 :         return 0;
   16111             : }
   16112             : 
   16113           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_fForwarderSlave(PyObject *obj, void *closure)
   16114             : {
   16115           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   16116           0 :         PyObject *py_fForwarderSlave;
   16117           0 :         py_fForwarderSlave = PyLong_FromUnsignedLongLong((uint32_t)(object->fForwarderSlave));
   16118           0 :         return py_fForwarderSlave;
   16119             : }
   16120             : 
   16121           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_fForwarderSlave(PyObject *py_obj, PyObject *value, void *closure)
   16122             : {
   16123           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   16124           0 :         if (value == NULL) {
   16125           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fForwarderSlave");
   16126           0 :                 return -1;
   16127             :         }
   16128             :         {
   16129           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fForwarderSlave));
   16130           0 :                 if (PyLong_Check(value)) {
   16131           0 :                         unsigned long long test_var;
   16132           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   16133           0 :                         if (PyErr_Occurred() != NULL) {
   16134           0 :                                 return -1;
   16135             :                         }
   16136           0 :                         if (test_var > uint_max) {
   16137           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   16138             :                                   PyLong_Type.tp_name, uint_max, test_var);
   16139           0 :                                 return -1;
   16140             :                         }
   16141           0 :                         object->fForwarderSlave = test_var;
   16142             :                 } else {
   16143           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   16144             :                           PyLong_Type.tp_name);
   16145           0 :                         return -1;
   16146             :                 }
   16147             :         }
   16148           0 :         return 0;
   16149             : }
   16150             : 
   16151           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_aipLocalMasters(PyObject *obj, void *closure)
   16152             : {
   16153           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   16154           0 :         PyObject *py_aipLocalMasters;
   16155           0 :         if (object->aipLocalMasters == NULL) {
   16156           0 :                 Py_RETURN_NONE;
   16157             :         }
   16158           0 :         if (object->aipLocalMasters == NULL) {
   16159           0 :                 py_aipLocalMasters = Py_None;
   16160           0 :                 Py_INCREF(py_aipLocalMasters);
   16161             :         } else {
   16162           0 :                 py_aipLocalMasters = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipLocalMasters, object->aipLocalMasters);
   16163             :         }
   16164           0 :         return py_aipLocalMasters;
   16165             : }
   16166             : 
   16167           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_aipLocalMasters(PyObject *py_obj, PyObject *value, void *closure)
   16168             : {
   16169           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   16170           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipLocalMasters));
   16171           0 :         if (value == NULL) {
   16172           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipLocalMasters");
   16173           0 :                 return -1;
   16174             :         }
   16175           0 :         if (value == Py_None) {
   16176           0 :                 object->aipLocalMasters = NULL;
   16177             :         } else {
   16178           0 :                 object->aipLocalMasters = NULL;
   16179           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
   16180           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   16181           0 :                         PyErr_NoMemory();
   16182           0 :                         return -1;
   16183             :                 }
   16184           0 :                 object->aipLocalMasters = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
   16185             :         }
   16186           0 :         return 0;
   16187             : }
   16188             : 
   16189           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_dwDpFlags(PyObject *obj, void *closure)
   16190             : {
   16191           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   16192           0 :         PyObject *py_dwDpFlags;
   16193           0 :         py_dwDpFlags = PyLong_FromUnsignedLongLong((uint32_t)(object->dwDpFlags));
   16194           0 :         return py_dwDpFlags;
   16195             : }
   16196             : 
   16197           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_dwDpFlags(PyObject *py_obj, PyObject *value, void *closure)
   16198             : {
   16199           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   16200           0 :         if (value == NULL) {
   16201           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwDpFlags");
   16202           0 :                 return -1;
   16203             :         }
   16204             :         {
   16205           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwDpFlags));
   16206           0 :                 if (PyLong_Check(value)) {
   16207           0 :                         unsigned long long test_var;
   16208           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   16209           0 :                         if (PyErr_Occurred() != NULL) {
   16210           0 :                                 return -1;
   16211             :                         }
   16212           0 :                         if (test_var > uint_max) {
   16213           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   16214             :                                   PyLong_Type.tp_name, uint_max, test_var);
   16215           0 :                                 return -1;
   16216             :                         }
   16217           0 :                         object->dwDpFlags = test_var;
   16218             :                 } else {
   16219           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   16220             :                           PyLong_Type.tp_name);
   16221           0 :                         return -1;
   16222             :                 }
   16223             :         }
   16224           0 :         return 0;
   16225             : }
   16226             : 
   16227           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_pszDpFqdn(PyObject *obj, void *closure)
   16228             : {
   16229           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   16230           0 :         PyObject *py_pszDpFqdn;
   16231           0 :         if (object->pszDpFqdn == NULL) {
   16232           0 :                 Py_RETURN_NONE;
   16233             :         }
   16234           0 :         if (object->pszDpFqdn == NULL) {
   16235           0 :                 py_pszDpFqdn = Py_None;
   16236           0 :                 Py_INCREF(py_pszDpFqdn);
   16237             :         } else {
   16238           0 :                 if (object->pszDpFqdn == NULL) {
   16239           0 :                         py_pszDpFqdn = Py_None;
   16240           0 :                         Py_INCREF(py_pszDpFqdn);
   16241             :                 } else {
   16242           0 :                         py_pszDpFqdn = PyUnicode_Decode(object->pszDpFqdn, strlen(object->pszDpFqdn), "utf-8", "ignore");
   16243             :                 }
   16244             :         }
   16245           0 :         return py_pszDpFqdn;
   16246             : }
   16247             : 
   16248           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_pszDpFqdn(PyObject *py_obj, PyObject *value, void *closure)
   16249             : {
   16250           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   16251           0 :         if (value == NULL) {
   16252           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszDpFqdn");
   16253           0 :                 return -1;
   16254             :         }
   16255           0 :         if (value == Py_None) {
   16256           0 :                 object->pszDpFqdn = NULL;
   16257             :         } else {
   16258           0 :                 object->pszDpFqdn = NULL;
   16259             :                 {
   16260           0 :                         const char *test_str;
   16261           0 :                         const char *talloc_str;
   16262           0 :                         PyObject *unicode = NULL;
   16263           0 :                         if (PyUnicode_Check(value)) {
   16264           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   16265           0 :                                 if (unicode == NULL) {
   16266           0 :                                         return -1;
   16267             :                                 }
   16268           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   16269           0 :                         } else if (PyBytes_Check(value)) {
   16270           0 :                                 test_str = PyBytes_AS_STRING(value);
   16271             :                         } else {
   16272           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   16273           0 :                                 return -1;
   16274             :                         }
   16275           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   16276           0 :                         if (unicode != NULL) {
   16277           0 :                                 Py_DECREF(unicode);
   16278             :                         }
   16279           0 :                         if (talloc_str == NULL) {
   16280           0 :                                 PyErr_NoMemory();
   16281           0 :                                 return -1;
   16282             :                         }
   16283           0 :                         object->pszDpFqdn = talloc_str;
   16284             :                 }
   16285             :         }
   16286           0 :         return 0;
   16287             : }
   16288             : 
   16289           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_pwszZoneDn(PyObject *obj, void *closure)
   16290             : {
   16291           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   16292           0 :         PyObject *py_pwszZoneDn;
   16293           0 :         if (object->pwszZoneDn == NULL) {
   16294           0 :                 Py_RETURN_NONE;
   16295             :         }
   16296           0 :         if (object->pwszZoneDn == NULL) {
   16297           0 :                 py_pwszZoneDn = Py_None;
   16298           0 :                 Py_INCREF(py_pwszZoneDn);
   16299             :         } else {
   16300           0 :                 if (object->pwszZoneDn == NULL) {
   16301           0 :                         py_pwszZoneDn = Py_None;
   16302           0 :                         Py_INCREF(py_pwszZoneDn);
   16303             :                 } else {
   16304           0 :                         py_pwszZoneDn = PyUnicode_Decode(object->pwszZoneDn, strlen(object->pwszZoneDn), "utf-8", "ignore");
   16305             :                 }
   16306             :         }
   16307           0 :         return py_pwszZoneDn;
   16308             : }
   16309             : 
   16310           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_pwszZoneDn(PyObject *py_obj, PyObject *value, void *closure)
   16311             : {
   16312           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   16313           0 :         if (value == NULL) {
   16314           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pwszZoneDn");
   16315           0 :                 return -1;
   16316             :         }
   16317           0 :         if (value == Py_None) {
   16318           0 :                 object->pwszZoneDn = NULL;
   16319             :         } else {
   16320           0 :                 object->pwszZoneDn = NULL;
   16321             :                 {
   16322           0 :                         const char *test_str;
   16323           0 :                         const char *talloc_str;
   16324           0 :                         PyObject *unicode = NULL;
   16325           0 :                         if (PyUnicode_Check(value)) {
   16326           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   16327           0 :                                 if (unicode == NULL) {
   16328           0 :                                         return -1;
   16329             :                                 }
   16330           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   16331           0 :                         } else if (PyBytes_Check(value)) {
   16332           0 :                                 test_str = PyBytes_AS_STRING(value);
   16333             :                         } else {
   16334           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   16335           0 :                                 return -1;
   16336             :                         }
   16337           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   16338           0 :                         if (unicode != NULL) {
   16339           0 :                                 Py_DECREF(unicode);
   16340             :                         }
   16341           0 :                         if (talloc_str == NULL) {
   16342           0 :                                 PyErr_NoMemory();
   16343           0 :                                 return -1;
   16344             :                         }
   16345           0 :                         object->pwszZoneDn = talloc_str;
   16346             :                 }
   16347             :         }
   16348           0 :         return 0;
   16349             : }
   16350             : 
   16351           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_dwLastSuccessfulSoaCheck(PyObject *obj, void *closure)
   16352             : {
   16353           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   16354           0 :         PyObject *py_dwLastSuccessfulSoaCheck;
   16355           0 :         py_dwLastSuccessfulSoaCheck = PyLong_FromUnsignedLongLong((uint32_t)(object->dwLastSuccessfulSoaCheck));
   16356           0 :         return py_dwLastSuccessfulSoaCheck;
   16357             : }
   16358             : 
   16359           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_dwLastSuccessfulSoaCheck(PyObject *py_obj, PyObject *value, void *closure)
   16360             : {
   16361           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   16362           0 :         if (value == NULL) {
   16363           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwLastSuccessfulSoaCheck");
   16364           0 :                 return -1;
   16365             :         }
   16366             :         {
   16367           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwLastSuccessfulSoaCheck));
   16368           0 :                 if (PyLong_Check(value)) {
   16369           0 :                         unsigned long long test_var;
   16370           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   16371           0 :                         if (PyErr_Occurred() != NULL) {
   16372           0 :                                 return -1;
   16373             :                         }
   16374           0 :                         if (test_var > uint_max) {
   16375           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   16376             :                                   PyLong_Type.tp_name, uint_max, test_var);
   16377           0 :                                 return -1;
   16378             :                         }
   16379           0 :                         object->dwLastSuccessfulSoaCheck = test_var;
   16380             :                 } else {
   16381           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   16382             :                           PyLong_Type.tp_name);
   16383           0 :                         return -1;
   16384             :                 }
   16385             :         }
   16386           0 :         return 0;
   16387             : }
   16388             : 
   16389           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_dwLastSuccessfulXfr(PyObject *obj, void *closure)
   16390             : {
   16391           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   16392           0 :         PyObject *py_dwLastSuccessfulXfr;
   16393           0 :         py_dwLastSuccessfulXfr = PyLong_FromUnsignedLongLong((uint32_t)(object->dwLastSuccessfulXfr));
   16394           0 :         return py_dwLastSuccessfulXfr;
   16395             : }
   16396             : 
   16397           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_dwLastSuccessfulXfr(PyObject *py_obj, PyObject *value, void *closure)
   16398             : {
   16399           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   16400           0 :         if (value == NULL) {
   16401           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwLastSuccessfulXfr");
   16402           0 :                 return -1;
   16403             :         }
   16404             :         {
   16405           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwLastSuccessfulXfr));
   16406           0 :                 if (PyLong_Check(value)) {
   16407           0 :                         unsigned long long test_var;
   16408           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   16409           0 :                         if (PyErr_Occurred() != NULL) {
   16410           0 :                                 return -1;
   16411             :                         }
   16412           0 :                         if (test_var > uint_max) {
   16413           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   16414             :                                   PyLong_Type.tp_name, uint_max, test_var);
   16415           0 :                                 return -1;
   16416             :                         }
   16417           0 :                         object->dwLastSuccessfulXfr = test_var;
   16418             :                 } else {
   16419           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   16420             :                           PyLong_Type.tp_name);
   16421           0 :                         return -1;
   16422             :                 }
   16423             :         }
   16424           0 :         return 0;
   16425             : }
   16426             : 
   16427           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_dwReserved1(PyObject *obj, void *closure)
   16428             : {
   16429           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   16430           0 :         PyObject *py_dwReserved1;
   16431           0 :         py_dwReserved1 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved1));
   16432           0 :         return py_dwReserved1;
   16433             : }
   16434             : 
   16435           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_dwReserved1(PyObject *py_obj, PyObject *value, void *closure)
   16436             : {
   16437           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   16438           0 :         if (value == NULL) {
   16439           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved1");
   16440           0 :                 return -1;
   16441             :         }
   16442             :         {
   16443           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved1));
   16444           0 :                 if (PyLong_Check(value)) {
   16445           0 :                         unsigned long long test_var;
   16446           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   16447           0 :                         if (PyErr_Occurred() != NULL) {
   16448           0 :                                 return -1;
   16449             :                         }
   16450           0 :                         if (test_var > uint_max) {
   16451           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   16452             :                                   PyLong_Type.tp_name, uint_max, test_var);
   16453           0 :                                 return -1;
   16454             :                         }
   16455           0 :                         object->dwReserved1 = test_var;
   16456             :                 } else {
   16457           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   16458             :                           PyLong_Type.tp_name);
   16459           0 :                         return -1;
   16460             :                 }
   16461             :         }
   16462           0 :         return 0;
   16463             : }
   16464             : 
   16465           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_dwReserved2(PyObject *obj, void *closure)
   16466             : {
   16467           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   16468           0 :         PyObject *py_dwReserved2;
   16469           0 :         py_dwReserved2 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved2));
   16470           0 :         return py_dwReserved2;
   16471             : }
   16472             : 
   16473           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_dwReserved2(PyObject *py_obj, PyObject *value, void *closure)
   16474             : {
   16475           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   16476           0 :         if (value == NULL) {
   16477           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved2");
   16478           0 :                 return -1;
   16479             :         }
   16480             :         {
   16481           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved2));
   16482           0 :                 if (PyLong_Check(value)) {
   16483           0 :                         unsigned long long test_var;
   16484           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   16485           0 :                         if (PyErr_Occurred() != NULL) {
   16486           0 :                                 return -1;
   16487             :                         }
   16488           0 :                         if (test_var > uint_max) {
   16489           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   16490             :                                   PyLong_Type.tp_name, uint_max, test_var);
   16491           0 :                                 return -1;
   16492             :                         }
   16493           0 :                         object->dwReserved2 = test_var;
   16494             :                 } else {
   16495           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   16496             :                           PyLong_Type.tp_name);
   16497           0 :                         return -1;
   16498             :                 }
   16499             :         }
   16500           0 :         return 0;
   16501             : }
   16502             : 
   16503           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_dwReserved3(PyObject *obj, void *closure)
   16504             : {
   16505           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   16506           0 :         PyObject *py_dwReserved3;
   16507           0 :         py_dwReserved3 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved3));
   16508           0 :         return py_dwReserved3;
   16509             : }
   16510             : 
   16511           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_dwReserved3(PyObject *py_obj, PyObject *value, void *closure)
   16512             : {
   16513           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   16514           0 :         if (value == NULL) {
   16515           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved3");
   16516           0 :                 return -1;
   16517             :         }
   16518             :         {
   16519           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved3));
   16520           0 :                 if (PyLong_Check(value)) {
   16521           0 :                         unsigned long long test_var;
   16522           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   16523           0 :                         if (PyErr_Occurred() != NULL) {
   16524           0 :                                 return -1;
   16525             :                         }
   16526           0 :                         if (test_var > uint_max) {
   16527           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   16528             :                                   PyLong_Type.tp_name, uint_max, test_var);
   16529           0 :                                 return -1;
   16530             :                         }
   16531           0 :                         object->dwReserved3 = test_var;
   16532             :                 } else {
   16533           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   16534             :                           PyLong_Type.tp_name);
   16535           0 :                         return -1;
   16536             :                 }
   16537             :         }
   16538           0 :         return 0;
   16539             : }
   16540             : 
   16541           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_dwReserved4(PyObject *obj, void *closure)
   16542             : {
   16543           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   16544           0 :         PyObject *py_dwReserved4;
   16545           0 :         py_dwReserved4 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved4));
   16546           0 :         return py_dwReserved4;
   16547             : }
   16548             : 
   16549           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_dwReserved4(PyObject *py_obj, PyObject *value, void *closure)
   16550             : {
   16551           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   16552           0 :         if (value == NULL) {
   16553           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved4");
   16554           0 :                 return -1;
   16555             :         }
   16556             :         {
   16557           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved4));
   16558           0 :                 if (PyLong_Check(value)) {
   16559           0 :                         unsigned long long test_var;
   16560           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   16561           0 :                         if (PyErr_Occurred() != NULL) {
   16562           0 :                                 return -1;
   16563             :                         }
   16564           0 :                         if (test_var > uint_max) {
   16565           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   16566             :                                   PyLong_Type.tp_name, uint_max, test_var);
   16567           0 :                                 return -1;
   16568             :                         }
   16569           0 :                         object->dwReserved4 = test_var;
   16570             :                 } else {
   16571           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   16572             :                           PyLong_Type.tp_name);
   16573           0 :                         return -1;
   16574             :                 }
   16575             :         }
   16576           0 :         return 0;
   16577             : }
   16578             : 
   16579           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_dwReserved5(PyObject *obj, void *closure)
   16580             : {
   16581           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   16582           0 :         PyObject *py_dwReserved5;
   16583           0 :         py_dwReserved5 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved5));
   16584           0 :         return py_dwReserved5;
   16585             : }
   16586             : 
   16587           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_dwReserved5(PyObject *py_obj, PyObject *value, void *closure)
   16588             : {
   16589           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   16590           0 :         if (value == NULL) {
   16591           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved5");
   16592           0 :                 return -1;
   16593             :         }
   16594             :         {
   16595           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved5));
   16596           0 :                 if (PyLong_Check(value)) {
   16597           0 :                         unsigned long long test_var;
   16598           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   16599           0 :                         if (PyErr_Occurred() != NULL) {
   16600           0 :                                 return -1;
   16601             :                         }
   16602           0 :                         if (test_var > uint_max) {
   16603           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   16604             :                                   PyLong_Type.tp_name, uint_max, test_var);
   16605           0 :                                 return -1;
   16606             :                         }
   16607           0 :                         object->dwReserved5 = test_var;
   16608             :                 } else {
   16609           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   16610             :                           PyLong_Type.tp_name);
   16611           0 :                         return -1;
   16612             :                 }
   16613             :         }
   16614           0 :         return 0;
   16615             : }
   16616             : 
   16617           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_pReserved1(PyObject *obj, void *closure)
   16618             : {
   16619           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   16620           0 :         PyObject *py_pReserved1;
   16621           0 :         if (object->pReserved1 == NULL) {
   16622           0 :                 Py_RETURN_NONE;
   16623             :         }
   16624           0 :         if (object->pReserved1 == NULL) {
   16625           0 :                 py_pReserved1 = Py_None;
   16626           0 :                 Py_INCREF(py_pReserved1);
   16627             :         } else {
   16628           0 :                 if (object->pReserved1 == NULL) {
   16629           0 :                         py_pReserved1 = Py_None;
   16630           0 :                         Py_INCREF(py_pReserved1);
   16631             :                 } else {
   16632           0 :                         py_pReserved1 = PyUnicode_Decode(object->pReserved1, strlen(object->pReserved1), "utf-8", "ignore");
   16633             :                 }
   16634             :         }
   16635           0 :         return py_pReserved1;
   16636             : }
   16637             : 
   16638           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_pReserved1(PyObject *py_obj, PyObject *value, void *closure)
   16639             : {
   16640           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   16641           0 :         if (value == NULL) {
   16642           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pReserved1");
   16643           0 :                 return -1;
   16644             :         }
   16645           0 :         if (value == Py_None) {
   16646           0 :                 object->pReserved1 = NULL;
   16647             :         } else {
   16648           0 :                 object->pReserved1 = NULL;
   16649             :                 {
   16650           0 :                         const char *test_str;
   16651           0 :                         const char *talloc_str;
   16652           0 :                         PyObject *unicode = NULL;
   16653           0 :                         if (PyUnicode_Check(value)) {
   16654           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   16655           0 :                                 if (unicode == NULL) {
   16656           0 :                                         return -1;
   16657             :                                 }
   16658           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   16659           0 :                         } else if (PyBytes_Check(value)) {
   16660           0 :                                 test_str = PyBytes_AS_STRING(value);
   16661             :                         } else {
   16662           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   16663           0 :                                 return -1;
   16664             :                         }
   16665           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   16666           0 :                         if (unicode != NULL) {
   16667           0 :                                 Py_DECREF(unicode);
   16668             :                         }
   16669           0 :                         if (talloc_str == NULL) {
   16670           0 :                                 PyErr_NoMemory();
   16671           0 :                                 return -1;
   16672             :                         }
   16673           0 :                         object->pReserved1 = talloc_str;
   16674             :                 }
   16675             :         }
   16676           0 :         return 0;
   16677             : }
   16678             : 
   16679           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_pReserved2(PyObject *obj, void *closure)
   16680             : {
   16681           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   16682           0 :         PyObject *py_pReserved2;
   16683           0 :         if (object->pReserved2 == NULL) {
   16684           0 :                 Py_RETURN_NONE;
   16685             :         }
   16686           0 :         if (object->pReserved2 == NULL) {
   16687           0 :                 py_pReserved2 = Py_None;
   16688           0 :                 Py_INCREF(py_pReserved2);
   16689             :         } else {
   16690           0 :                 if (object->pReserved2 == NULL) {
   16691           0 :                         py_pReserved2 = Py_None;
   16692           0 :                         Py_INCREF(py_pReserved2);
   16693             :                 } else {
   16694           0 :                         py_pReserved2 = PyUnicode_Decode(object->pReserved2, strlen(object->pReserved2), "utf-8", "ignore");
   16695             :                 }
   16696             :         }
   16697           0 :         return py_pReserved2;
   16698             : }
   16699             : 
   16700           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_pReserved2(PyObject *py_obj, PyObject *value, void *closure)
   16701             : {
   16702           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   16703           0 :         if (value == NULL) {
   16704           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pReserved2");
   16705           0 :                 return -1;
   16706             :         }
   16707           0 :         if (value == Py_None) {
   16708           0 :                 object->pReserved2 = NULL;
   16709             :         } else {
   16710           0 :                 object->pReserved2 = NULL;
   16711             :                 {
   16712           0 :                         const char *test_str;
   16713           0 :                         const char *talloc_str;
   16714           0 :                         PyObject *unicode = NULL;
   16715           0 :                         if (PyUnicode_Check(value)) {
   16716           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   16717           0 :                                 if (unicode == NULL) {
   16718           0 :                                         return -1;
   16719             :                                 }
   16720           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   16721           0 :                         } else if (PyBytes_Check(value)) {
   16722           0 :                                 test_str = PyBytes_AS_STRING(value);
   16723             :                         } else {
   16724           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   16725           0 :                                 return -1;
   16726             :                         }
   16727           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   16728           0 :                         if (unicode != NULL) {
   16729           0 :                                 Py_DECREF(unicode);
   16730             :                         }
   16731           0 :                         if (talloc_str == NULL) {
   16732           0 :                                 PyErr_NoMemory();
   16733           0 :                                 return -1;
   16734             :                         }
   16735           0 :                         object->pReserved2 = talloc_str;
   16736             :                 }
   16737             :         }
   16738           0 :         return 0;
   16739             : }
   16740             : 
   16741           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_pReserved3(PyObject *obj, void *closure)
   16742             : {
   16743           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   16744           0 :         PyObject *py_pReserved3;
   16745           0 :         if (object->pReserved3 == NULL) {
   16746           0 :                 Py_RETURN_NONE;
   16747             :         }
   16748           0 :         if (object->pReserved3 == NULL) {
   16749           0 :                 py_pReserved3 = Py_None;
   16750           0 :                 Py_INCREF(py_pReserved3);
   16751             :         } else {
   16752           0 :                 if (object->pReserved3 == NULL) {
   16753           0 :                         py_pReserved3 = Py_None;
   16754           0 :                         Py_INCREF(py_pReserved3);
   16755             :                 } else {
   16756           0 :                         py_pReserved3 = PyUnicode_Decode(object->pReserved3, strlen(object->pReserved3), "utf-8", "ignore");
   16757             :                 }
   16758             :         }
   16759           0 :         return py_pReserved3;
   16760             : }
   16761             : 
   16762           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_pReserved3(PyObject *py_obj, PyObject *value, void *closure)
   16763             : {
   16764           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   16765           0 :         if (value == NULL) {
   16766           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pReserved3");
   16767           0 :                 return -1;
   16768             :         }
   16769           0 :         if (value == Py_None) {
   16770           0 :                 object->pReserved3 = NULL;
   16771             :         } else {
   16772           0 :                 object->pReserved3 = NULL;
   16773             :                 {
   16774           0 :                         const char *test_str;
   16775           0 :                         const char *talloc_str;
   16776           0 :                         PyObject *unicode = NULL;
   16777           0 :                         if (PyUnicode_Check(value)) {
   16778           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   16779           0 :                                 if (unicode == NULL) {
   16780           0 :                                         return -1;
   16781             :                                 }
   16782           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   16783           0 :                         } else if (PyBytes_Check(value)) {
   16784           0 :                                 test_str = PyBytes_AS_STRING(value);
   16785             :                         } else {
   16786           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   16787           0 :                                 return -1;
   16788             :                         }
   16789           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   16790           0 :                         if (unicode != NULL) {
   16791           0 :                                 Py_DECREF(unicode);
   16792             :                         }
   16793           0 :                         if (talloc_str == NULL) {
   16794           0 :                                 PyErr_NoMemory();
   16795           0 :                                 return -1;
   16796             :                         }
   16797           0 :                         object->pReserved3 = talloc_str;
   16798             :                 }
   16799             :         }
   16800           0 :         return 0;
   16801             : }
   16802             : 
   16803           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_get_pReserved4(PyObject *obj, void *closure)
   16804             : {
   16805           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   16806           0 :         PyObject *py_pReserved4;
   16807           0 :         if (object->pReserved4 == NULL) {
   16808           0 :                 Py_RETURN_NONE;
   16809             :         }
   16810           0 :         if (object->pReserved4 == NULL) {
   16811           0 :                 py_pReserved4 = Py_None;
   16812           0 :                 Py_INCREF(py_pReserved4);
   16813             :         } else {
   16814           0 :                 if (object->pReserved4 == NULL) {
   16815           0 :                         py_pReserved4 = Py_None;
   16816           0 :                         Py_INCREF(py_pReserved4);
   16817             :                 } else {
   16818           0 :                         py_pReserved4 = PyUnicode_Decode(object->pReserved4, strlen(object->pReserved4), "utf-8", "ignore");
   16819             :                 }
   16820             :         }
   16821           0 :         return py_pReserved4;
   16822             : }
   16823             : 
   16824           0 : static int py_DNS_RPC_ZONE_INFO_DOTNET_set_pReserved4(PyObject *py_obj, PyObject *value, void *closure)
   16825             : {
   16826           0 :         struct DNS_RPC_ZONE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   16827           0 :         if (value == NULL) {
   16828           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pReserved4");
   16829           0 :                 return -1;
   16830             :         }
   16831           0 :         if (value == Py_None) {
   16832           0 :                 object->pReserved4 = NULL;
   16833             :         } else {
   16834           0 :                 object->pReserved4 = NULL;
   16835             :                 {
   16836           0 :                         const char *test_str;
   16837           0 :                         const char *talloc_str;
   16838           0 :                         PyObject *unicode = NULL;
   16839           0 :                         if (PyUnicode_Check(value)) {
   16840           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   16841           0 :                                 if (unicode == NULL) {
   16842           0 :                                         return -1;
   16843             :                                 }
   16844           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   16845           0 :                         } else if (PyBytes_Check(value)) {
   16846           0 :                                 test_str = PyBytes_AS_STRING(value);
   16847             :                         } else {
   16848           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   16849           0 :                                 return -1;
   16850             :                         }
   16851           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   16852           0 :                         if (unicode != NULL) {
   16853           0 :                                 Py_DECREF(unicode);
   16854             :                         }
   16855           0 :                         if (talloc_str == NULL) {
   16856           0 :                                 PyErr_NoMemory();
   16857           0 :                                 return -1;
   16858             :                         }
   16859           0 :                         object->pReserved4 = talloc_str;
   16860             :                 }
   16861             :         }
   16862           0 :         return 0;
   16863             : }
   16864             : 
   16865             : static PyGetSetDef py_DNS_RPC_ZONE_INFO_DOTNET_getsetters[] = {
   16866             :         {
   16867             :                 .name = discard_const_p(char, "dwRpcStructureVersion"),
   16868             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_dwRpcStructureVersion,
   16869             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_dwRpcStructureVersion,
   16870             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   16871             :         },
   16872             :         {
   16873             :                 .name = discard_const_p(char, "dwReserved0"),
   16874             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_dwReserved0,
   16875             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_dwReserved0,
   16876             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   16877             :         },
   16878             :         {
   16879             :                 .name = discard_const_p(char, "pszZoneName"),
   16880             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_pszZoneName,
   16881             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_pszZoneName,
   16882             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   16883             :         },
   16884             :         {
   16885             :                 .name = discard_const_p(char, "dwZoneType"),
   16886             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_dwZoneType,
   16887             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_dwZoneType,
   16888             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   16889             :         },
   16890             :         {
   16891             :                 .name = discard_const_p(char, "fReverse"),
   16892             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_fReverse,
   16893             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_fReverse,
   16894             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   16895             :         },
   16896             :         {
   16897             :                 .name = discard_const_p(char, "fAllowUpdate"),
   16898             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_fAllowUpdate,
   16899             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_fAllowUpdate,
   16900             :                 .doc = discard_const_p(char, "PIDL-generated element of base type dns_zone_update")
   16901             :         },
   16902             :         {
   16903             :                 .name = discard_const_p(char, "fPaused"),
   16904             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_fPaused,
   16905             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_fPaused,
   16906             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   16907             :         },
   16908             :         {
   16909             :                 .name = discard_const_p(char, "fShutdown"),
   16910             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_fShutdown,
   16911             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_fShutdown,
   16912             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   16913             :         },
   16914             :         {
   16915             :                 .name = discard_const_p(char, "fAutoCreated"),
   16916             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_fAutoCreated,
   16917             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_fAutoCreated,
   16918             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   16919             :         },
   16920             :         {
   16921             :                 .name = discard_const_p(char, "fUseDatabase"),
   16922             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_fUseDatabase,
   16923             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_fUseDatabase,
   16924             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   16925             :         },
   16926             :         {
   16927             :                 .name = discard_const_p(char, "pszDataFile"),
   16928             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_pszDataFile,
   16929             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_pszDataFile,
   16930             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   16931             :         },
   16932             :         {
   16933             :                 .name = discard_const_p(char, "aipMasters"),
   16934             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_aipMasters,
   16935             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_aipMasters,
   16936             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
   16937             :         },
   16938             :         {
   16939             :                 .name = discard_const_p(char, "fSecureSecondaries"),
   16940             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_fSecureSecondaries,
   16941             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_fSecureSecondaries,
   16942             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ZONE_SECONDARY_SECURITY")
   16943             :         },
   16944             :         {
   16945             :                 .name = discard_const_p(char, "fNotifyLevel"),
   16946             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_fNotifyLevel,
   16947             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_fNotifyLevel,
   16948             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ZONE_NOTIFY_LEVEL")
   16949             :         },
   16950             :         {
   16951             :                 .name = discard_const_p(char, "aipSecondaries"),
   16952             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_aipSecondaries,
   16953             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_aipSecondaries,
   16954             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
   16955             :         },
   16956             :         {
   16957             :                 .name = discard_const_p(char, "aipNotify"),
   16958             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_aipNotify,
   16959             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_aipNotify,
   16960             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
   16961             :         },
   16962             :         {
   16963             :                 .name = discard_const_p(char, "fUseWins"),
   16964             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_fUseWins,
   16965             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_fUseWins,
   16966             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   16967             :         },
   16968             :         {
   16969             :                 .name = discard_const_p(char, "fUseNbstat"),
   16970             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_fUseNbstat,
   16971             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_fUseNbstat,
   16972             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   16973             :         },
   16974             :         {
   16975             :                 .name = discard_const_p(char, "fAging"),
   16976             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_fAging,
   16977             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_fAging,
   16978             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   16979             :         },
   16980             :         {
   16981             :                 .name = discard_const_p(char, "dwNoRefreshInterval"),
   16982             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_dwNoRefreshInterval,
   16983             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_dwNoRefreshInterval,
   16984             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   16985             :         },
   16986             :         {
   16987             :                 .name = discard_const_p(char, "dwRefreshInterval"),
   16988             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_dwRefreshInterval,
   16989             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_dwRefreshInterval,
   16990             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   16991             :         },
   16992             :         {
   16993             :                 .name = discard_const_p(char, "dwAvailForScavengeTime"),
   16994             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_dwAvailForScavengeTime,
   16995             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_dwAvailForScavengeTime,
   16996             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   16997             :         },
   16998             :         {
   16999             :                 .name = discard_const_p(char, "aipScavengeServers"),
   17000             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_aipScavengeServers,
   17001             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_aipScavengeServers,
   17002             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
   17003             :         },
   17004             :         {
   17005             :                 .name = discard_const_p(char, "dwForwarderTimeout"),
   17006             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_dwForwarderTimeout,
   17007             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_dwForwarderTimeout,
   17008             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   17009             :         },
   17010             :         {
   17011             :                 .name = discard_const_p(char, "fForwarderSlave"),
   17012             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_fForwarderSlave,
   17013             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_fForwarderSlave,
   17014             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   17015             :         },
   17016             :         {
   17017             :                 .name = discard_const_p(char, "aipLocalMasters"),
   17018             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_aipLocalMasters,
   17019             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_aipLocalMasters,
   17020             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
   17021             :         },
   17022             :         {
   17023             :                 .name = discard_const_p(char, "dwDpFlags"),
   17024             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_dwDpFlags,
   17025             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_dwDpFlags,
   17026             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   17027             :         },
   17028             :         {
   17029             :                 .name = discard_const_p(char, "pszDpFqdn"),
   17030             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_pszDpFqdn,
   17031             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_pszDpFqdn,
   17032             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   17033             :         },
   17034             :         {
   17035             :                 .name = discard_const_p(char, "pwszZoneDn"),
   17036             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_pwszZoneDn,
   17037             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_pwszZoneDn,
   17038             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
   17039             :         },
   17040             :         {
   17041             :                 .name = discard_const_p(char, "dwLastSuccessfulSoaCheck"),
   17042             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_dwLastSuccessfulSoaCheck,
   17043             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_dwLastSuccessfulSoaCheck,
   17044             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   17045             :         },
   17046             :         {
   17047             :                 .name = discard_const_p(char, "dwLastSuccessfulXfr"),
   17048             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_dwLastSuccessfulXfr,
   17049             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_dwLastSuccessfulXfr,
   17050             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   17051             :         },
   17052             :         {
   17053             :                 .name = discard_const_p(char, "dwReserved1"),
   17054             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_dwReserved1,
   17055             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_dwReserved1,
   17056             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   17057             :         },
   17058             :         {
   17059             :                 .name = discard_const_p(char, "dwReserved2"),
   17060             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_dwReserved2,
   17061             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_dwReserved2,
   17062             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   17063             :         },
   17064             :         {
   17065             :                 .name = discard_const_p(char, "dwReserved3"),
   17066             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_dwReserved3,
   17067             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_dwReserved3,
   17068             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   17069             :         },
   17070             :         {
   17071             :                 .name = discard_const_p(char, "dwReserved4"),
   17072             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_dwReserved4,
   17073             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_dwReserved4,
   17074             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   17075             :         },
   17076             :         {
   17077             :                 .name = discard_const_p(char, "dwReserved5"),
   17078             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_dwReserved5,
   17079             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_dwReserved5,
   17080             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   17081             :         },
   17082             :         {
   17083             :                 .name = discard_const_p(char, "pReserved1"),
   17084             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_pReserved1,
   17085             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_pReserved1,
   17086             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   17087             :         },
   17088             :         {
   17089             :                 .name = discard_const_p(char, "pReserved2"),
   17090             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_pReserved2,
   17091             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_pReserved2,
   17092             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   17093             :         },
   17094             :         {
   17095             :                 .name = discard_const_p(char, "pReserved3"),
   17096             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_pReserved3,
   17097             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_pReserved3,
   17098             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   17099             :         },
   17100             :         {
   17101             :                 .name = discard_const_p(char, "pReserved4"),
   17102             :                 .get = py_DNS_RPC_ZONE_INFO_DOTNET_get_pReserved4,
   17103             :                 .set = py_DNS_RPC_ZONE_INFO_DOTNET_set_pReserved4,
   17104             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   17105             :         },
   17106             :         { .name = NULL }
   17107             : };
   17108             : 
   17109           0 : static PyObject *py_DNS_RPC_ZONE_INFO_DOTNET_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   17110             : {
   17111           0 :         return pytalloc_new(struct DNS_RPC_ZONE_INFO_DOTNET, type);
   17112             : }
   17113             : 
   17114             : 
   17115             : static PyTypeObject DNS_RPC_ZONE_INFO_DOTNET_Type = {
   17116             :         PyVarObject_HEAD_INIT(NULL, 0)
   17117             :         .tp_name = "dnsserver.DNS_RPC_ZONE_INFO_DOTNET",
   17118             :         .tp_getset = py_DNS_RPC_ZONE_INFO_DOTNET_getsetters,
   17119             :         .tp_methods = NULL,
   17120             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   17121             :         .tp_new = py_DNS_RPC_ZONE_INFO_DOTNET_new,
   17122             : };
   17123             : 
   17124             : 
   17125          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_dwRpcStructureVersion(PyObject *obj, void *closure)
   17126             : {
   17127          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   17128           0 :         PyObject *py_dwRpcStructureVersion;
   17129          17 :         py_dwRpcStructureVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcStructureVersion));
   17130          17 :         return py_dwRpcStructureVersion;
   17131             : }
   17132             : 
   17133           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_dwRpcStructureVersion(PyObject *py_obj, PyObject *value, void *closure)
   17134             : {
   17135           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   17136           0 :         if (value == NULL) {
   17137           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcStructureVersion");
   17138           0 :                 return -1;
   17139             :         }
   17140             :         {
   17141           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcStructureVersion));
   17142           0 :                 if (PyLong_Check(value)) {
   17143           0 :                         unsigned long long test_var;
   17144           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   17145           0 :                         if (PyErr_Occurred() != NULL) {
   17146           0 :                                 return -1;
   17147             :                         }
   17148           0 :                         if (test_var > uint_max) {
   17149           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   17150             :                                   PyLong_Type.tp_name, uint_max, test_var);
   17151           0 :                                 return -1;
   17152             :                         }
   17153           0 :                         object->dwRpcStructureVersion = test_var;
   17154             :                 } else {
   17155           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   17156             :                           PyLong_Type.tp_name);
   17157           0 :                         return -1;
   17158             :                 }
   17159             :         }
   17160           0 :         return 0;
   17161             : }
   17162             : 
   17163           0 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_dwReserved0(PyObject *obj, void *closure)
   17164             : {
   17165           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   17166           0 :         PyObject *py_dwReserved0;
   17167           0 :         py_dwReserved0 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved0));
   17168           0 :         return py_dwReserved0;
   17169             : }
   17170             : 
   17171           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_dwReserved0(PyObject *py_obj, PyObject *value, void *closure)
   17172             : {
   17173           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   17174           0 :         if (value == NULL) {
   17175           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved0");
   17176           0 :                 return -1;
   17177             :         }
   17178             :         {
   17179           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved0));
   17180           0 :                 if (PyLong_Check(value)) {
   17181           0 :                         unsigned long long test_var;
   17182           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   17183           0 :                         if (PyErr_Occurred() != NULL) {
   17184           0 :                                 return -1;
   17185             :                         }
   17186           0 :                         if (test_var > uint_max) {
   17187           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   17188             :                                   PyLong_Type.tp_name, uint_max, test_var);
   17189           0 :                                 return -1;
   17190             :                         }
   17191           0 :                         object->dwReserved0 = test_var;
   17192             :                 } else {
   17193           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   17194             :                           PyLong_Type.tp_name);
   17195           0 :                         return -1;
   17196             :                 }
   17197             :         }
   17198           0 :         return 0;
   17199             : }
   17200             : 
   17201          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_pszZoneName(PyObject *obj, void *closure)
   17202             : {
   17203          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   17204           0 :         PyObject *py_pszZoneName;
   17205          17 :         if (object->pszZoneName == NULL) {
   17206           0 :                 Py_RETURN_NONE;
   17207             :         }
   17208          17 :         if (object->pszZoneName == NULL) {
   17209           0 :                 py_pszZoneName = Py_None;
   17210           0 :                 Py_INCREF(py_pszZoneName);
   17211             :         } else {
   17212          17 :                 if (object->pszZoneName == NULL) {
   17213           0 :                         py_pszZoneName = Py_None;
   17214           0 :                         Py_INCREF(py_pszZoneName);
   17215             :                 } else {
   17216          17 :                         py_pszZoneName = PyUnicode_Decode(object->pszZoneName, strlen(object->pszZoneName), "utf-8", "ignore");
   17217             :                 }
   17218             :         }
   17219          17 :         return py_pszZoneName;
   17220             : }
   17221             : 
   17222           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_pszZoneName(PyObject *py_obj, PyObject *value, void *closure)
   17223             : {
   17224           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   17225           0 :         if (value == NULL) {
   17226           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszZoneName");
   17227           0 :                 return -1;
   17228             :         }
   17229           0 :         if (value == Py_None) {
   17230           0 :                 object->pszZoneName = NULL;
   17231             :         } else {
   17232           0 :                 object->pszZoneName = NULL;
   17233             :                 {
   17234           0 :                         const char *test_str;
   17235           0 :                         const char *talloc_str;
   17236           0 :                         PyObject *unicode = NULL;
   17237           0 :                         if (PyUnicode_Check(value)) {
   17238           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   17239           0 :                                 if (unicode == NULL) {
   17240           0 :                                         return -1;
   17241             :                                 }
   17242           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   17243           0 :                         } else if (PyBytes_Check(value)) {
   17244           0 :                                 test_str = PyBytes_AS_STRING(value);
   17245             :                         } else {
   17246           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   17247           0 :                                 return -1;
   17248             :                         }
   17249           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   17250           0 :                         if (unicode != NULL) {
   17251           0 :                                 Py_DECREF(unicode);
   17252             :                         }
   17253           0 :                         if (talloc_str == NULL) {
   17254           0 :                                 PyErr_NoMemory();
   17255           0 :                                 return -1;
   17256             :                         }
   17257           0 :                         object->pszZoneName = talloc_str;
   17258             :                 }
   17259             :         }
   17260           0 :         return 0;
   17261             : }
   17262             : 
   17263          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_dwZoneType(PyObject *obj, void *closure)
   17264             : {
   17265          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   17266           0 :         PyObject *py_dwZoneType;
   17267          17 :         py_dwZoneType = PyLong_FromUnsignedLongLong((uint32_t)(object->dwZoneType));
   17268          17 :         return py_dwZoneType;
   17269             : }
   17270             : 
   17271           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_dwZoneType(PyObject *py_obj, PyObject *value, void *closure)
   17272             : {
   17273           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   17274           0 :         if (value == NULL) {
   17275           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwZoneType");
   17276           0 :                 return -1;
   17277             :         }
   17278             :         {
   17279           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwZoneType));
   17280           0 :                 if (PyLong_Check(value)) {
   17281           0 :                         unsigned long long test_var;
   17282           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   17283           0 :                         if (PyErr_Occurred() != NULL) {
   17284           0 :                                 return -1;
   17285             :                         }
   17286           0 :                         if (test_var > uint_max) {
   17287           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   17288             :                                   PyLong_Type.tp_name, uint_max, test_var);
   17289           0 :                                 return -1;
   17290             :                         }
   17291           0 :                         object->dwZoneType = test_var;
   17292             :                 } else {
   17293           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   17294             :                           PyLong_Type.tp_name);
   17295           0 :                         return -1;
   17296             :                 }
   17297             :         }
   17298           0 :         return 0;
   17299             : }
   17300             : 
   17301          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_fReverse(PyObject *obj, void *closure)
   17302             : {
   17303          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   17304           0 :         PyObject *py_fReverse;
   17305          17 :         py_fReverse = PyLong_FromUnsignedLongLong((uint32_t)(object->fReverse));
   17306          17 :         return py_fReverse;
   17307             : }
   17308             : 
   17309           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_fReverse(PyObject *py_obj, PyObject *value, void *closure)
   17310             : {
   17311           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   17312           0 :         if (value == NULL) {
   17313           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fReverse");
   17314           0 :                 return -1;
   17315             :         }
   17316             :         {
   17317           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fReverse));
   17318           0 :                 if (PyLong_Check(value)) {
   17319           0 :                         unsigned long long test_var;
   17320           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   17321           0 :                         if (PyErr_Occurred() != NULL) {
   17322           0 :                                 return -1;
   17323             :                         }
   17324           0 :                         if (test_var > uint_max) {
   17325           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   17326             :                                   PyLong_Type.tp_name, uint_max, test_var);
   17327           0 :                                 return -1;
   17328             :                         }
   17329           0 :                         object->fReverse = test_var;
   17330             :                 } else {
   17331           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   17332             :                           PyLong_Type.tp_name);
   17333           0 :                         return -1;
   17334             :                 }
   17335             :         }
   17336           0 :         return 0;
   17337             : }
   17338             : 
   17339          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_fAllowUpdate(PyObject *obj, void *closure)
   17340             : {
   17341          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   17342           0 :         PyObject *py_fAllowUpdate;
   17343          17 :         py_fAllowUpdate = PyLong_FromLong((uint16_t)(object->fAllowUpdate));
   17344          17 :         return py_fAllowUpdate;
   17345             : }
   17346             : 
   17347           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_fAllowUpdate(PyObject *py_obj, PyObject *value, void *closure)
   17348             : {
   17349           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   17350           0 :         if (value == NULL) {
   17351           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAllowUpdate");
   17352           0 :                 return -1;
   17353             :         }
   17354             :         {
   17355           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAllowUpdate));
   17356           0 :                 if (PyLong_Check(value)) {
   17357           0 :                         unsigned long long test_var;
   17358           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   17359           0 :                         if (PyErr_Occurred() != NULL) {
   17360           0 :                                 return -1;
   17361             :                         }
   17362           0 :                         if (test_var > uint_max) {
   17363           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   17364             :                                   PyLong_Type.tp_name, uint_max, test_var);
   17365           0 :                                 return -1;
   17366             :                         }
   17367           0 :                         object->fAllowUpdate = test_var;
   17368             :                 } else {
   17369           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   17370             :                           PyLong_Type.tp_name);
   17371           0 :                         return -1;
   17372             :                 }
   17373             :         }
   17374           0 :         return 0;
   17375             : }
   17376             : 
   17377          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_fPaused(PyObject *obj, void *closure)
   17378             : {
   17379          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   17380           0 :         PyObject *py_fPaused;
   17381          17 :         py_fPaused = PyLong_FromUnsignedLongLong((uint32_t)(object->fPaused));
   17382          17 :         return py_fPaused;
   17383             : }
   17384             : 
   17385           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_fPaused(PyObject *py_obj, PyObject *value, void *closure)
   17386             : {
   17387           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   17388           0 :         if (value == NULL) {
   17389           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fPaused");
   17390           0 :                 return -1;
   17391             :         }
   17392             :         {
   17393           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fPaused));
   17394           0 :                 if (PyLong_Check(value)) {
   17395           0 :                         unsigned long long test_var;
   17396           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   17397           0 :                         if (PyErr_Occurred() != NULL) {
   17398           0 :                                 return -1;
   17399             :                         }
   17400           0 :                         if (test_var > uint_max) {
   17401           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   17402             :                                   PyLong_Type.tp_name, uint_max, test_var);
   17403           0 :                                 return -1;
   17404             :                         }
   17405           0 :                         object->fPaused = test_var;
   17406             :                 } else {
   17407           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   17408             :                           PyLong_Type.tp_name);
   17409           0 :                         return -1;
   17410             :                 }
   17411             :         }
   17412           0 :         return 0;
   17413             : }
   17414             : 
   17415          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_fShutdown(PyObject *obj, void *closure)
   17416             : {
   17417          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   17418           0 :         PyObject *py_fShutdown;
   17419          17 :         py_fShutdown = PyLong_FromUnsignedLongLong((uint32_t)(object->fShutdown));
   17420          17 :         return py_fShutdown;
   17421             : }
   17422             : 
   17423           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_fShutdown(PyObject *py_obj, PyObject *value, void *closure)
   17424             : {
   17425           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   17426           0 :         if (value == NULL) {
   17427           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fShutdown");
   17428           0 :                 return -1;
   17429             :         }
   17430             :         {
   17431           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fShutdown));
   17432           0 :                 if (PyLong_Check(value)) {
   17433           0 :                         unsigned long long test_var;
   17434           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   17435           0 :                         if (PyErr_Occurred() != NULL) {
   17436           0 :                                 return -1;
   17437             :                         }
   17438           0 :                         if (test_var > uint_max) {
   17439           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   17440             :                                   PyLong_Type.tp_name, uint_max, test_var);
   17441           0 :                                 return -1;
   17442             :                         }
   17443           0 :                         object->fShutdown = test_var;
   17444             :                 } else {
   17445           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   17446             :                           PyLong_Type.tp_name);
   17447           0 :                         return -1;
   17448             :                 }
   17449             :         }
   17450           0 :         return 0;
   17451             : }
   17452             : 
   17453          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_fAutoCreated(PyObject *obj, void *closure)
   17454             : {
   17455          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   17456           0 :         PyObject *py_fAutoCreated;
   17457          17 :         py_fAutoCreated = PyLong_FromUnsignedLongLong((uint32_t)(object->fAutoCreated));
   17458          17 :         return py_fAutoCreated;
   17459             : }
   17460             : 
   17461           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_fAutoCreated(PyObject *py_obj, PyObject *value, void *closure)
   17462             : {
   17463           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   17464           0 :         if (value == NULL) {
   17465           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAutoCreated");
   17466           0 :                 return -1;
   17467             :         }
   17468             :         {
   17469           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAutoCreated));
   17470           0 :                 if (PyLong_Check(value)) {
   17471           0 :                         unsigned long long test_var;
   17472           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   17473           0 :                         if (PyErr_Occurred() != NULL) {
   17474           0 :                                 return -1;
   17475             :                         }
   17476           0 :                         if (test_var > uint_max) {
   17477           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   17478             :                                   PyLong_Type.tp_name, uint_max, test_var);
   17479           0 :                                 return -1;
   17480             :                         }
   17481           0 :                         object->fAutoCreated = test_var;
   17482             :                 } else {
   17483           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   17484             :                           PyLong_Type.tp_name);
   17485           0 :                         return -1;
   17486             :                 }
   17487             :         }
   17488           0 :         return 0;
   17489             : }
   17490             : 
   17491          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_fUseDatabase(PyObject *obj, void *closure)
   17492             : {
   17493          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   17494           0 :         PyObject *py_fUseDatabase;
   17495          17 :         py_fUseDatabase = PyLong_FromUnsignedLongLong((uint32_t)(object->fUseDatabase));
   17496          17 :         return py_fUseDatabase;
   17497             : }
   17498             : 
   17499           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_fUseDatabase(PyObject *py_obj, PyObject *value, void *closure)
   17500             : {
   17501           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   17502           0 :         if (value == NULL) {
   17503           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fUseDatabase");
   17504           0 :                 return -1;
   17505             :         }
   17506             :         {
   17507           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fUseDatabase));
   17508           0 :                 if (PyLong_Check(value)) {
   17509           0 :                         unsigned long long test_var;
   17510           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   17511           0 :                         if (PyErr_Occurred() != NULL) {
   17512           0 :                                 return -1;
   17513             :                         }
   17514           0 :                         if (test_var > uint_max) {
   17515           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   17516             :                                   PyLong_Type.tp_name, uint_max, test_var);
   17517           0 :                                 return -1;
   17518             :                         }
   17519           0 :                         object->fUseDatabase = test_var;
   17520             :                 } else {
   17521           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   17522             :                           PyLong_Type.tp_name);
   17523           0 :                         return -1;
   17524             :                 }
   17525             :         }
   17526           0 :         return 0;
   17527             : }
   17528             : 
   17529          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_pszDataFile(PyObject *obj, void *closure)
   17530             : {
   17531          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   17532           0 :         PyObject *py_pszDataFile;
   17533          17 :         if (object->pszDataFile == NULL) {
   17534          17 :                 Py_RETURN_NONE;
   17535             :         }
   17536           0 :         if (object->pszDataFile == NULL) {
   17537           0 :                 py_pszDataFile = Py_None;
   17538           0 :                 Py_INCREF(py_pszDataFile);
   17539             :         } else {
   17540           0 :                 if (object->pszDataFile == NULL) {
   17541           0 :                         py_pszDataFile = Py_None;
   17542           0 :                         Py_INCREF(py_pszDataFile);
   17543             :                 } else {
   17544           0 :                         py_pszDataFile = PyUnicode_Decode(object->pszDataFile, strlen(object->pszDataFile), "utf-8", "ignore");
   17545             :                 }
   17546             :         }
   17547           0 :         return py_pszDataFile;
   17548             : }
   17549             : 
   17550           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_pszDataFile(PyObject *py_obj, PyObject *value, void *closure)
   17551             : {
   17552           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   17553           0 :         if (value == NULL) {
   17554           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszDataFile");
   17555           0 :                 return -1;
   17556             :         }
   17557           0 :         if (value == Py_None) {
   17558           0 :                 object->pszDataFile = NULL;
   17559             :         } else {
   17560           0 :                 object->pszDataFile = NULL;
   17561             :                 {
   17562           0 :                         const char *test_str;
   17563           0 :                         const char *talloc_str;
   17564           0 :                         PyObject *unicode = NULL;
   17565           0 :                         if (PyUnicode_Check(value)) {
   17566           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   17567           0 :                                 if (unicode == NULL) {
   17568           0 :                                         return -1;
   17569             :                                 }
   17570           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   17571           0 :                         } else if (PyBytes_Check(value)) {
   17572           0 :                                 test_str = PyBytes_AS_STRING(value);
   17573             :                         } else {
   17574           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   17575           0 :                                 return -1;
   17576             :                         }
   17577           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   17578           0 :                         if (unicode != NULL) {
   17579           0 :                                 Py_DECREF(unicode);
   17580             :                         }
   17581           0 :                         if (talloc_str == NULL) {
   17582           0 :                                 PyErr_NoMemory();
   17583           0 :                                 return -1;
   17584             :                         }
   17585           0 :                         object->pszDataFile = talloc_str;
   17586             :                 }
   17587             :         }
   17588           0 :         return 0;
   17589             : }
   17590             : 
   17591          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_aipMasters(PyObject *obj, void *closure)
   17592             : {
   17593          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   17594           0 :         PyObject *py_aipMasters;
   17595          17 :         if (object->aipMasters == NULL) {
   17596          17 :                 Py_RETURN_NONE;
   17597             :         }
   17598           0 :         if (object->aipMasters == NULL) {
   17599           0 :                 py_aipMasters = Py_None;
   17600           0 :                 Py_INCREF(py_aipMasters);
   17601             :         } else {
   17602           0 :                 py_aipMasters = pytalloc_reference_ex(&DNS_ADDR_ARRAY_Type, object->aipMasters, object->aipMasters);
   17603             :         }
   17604           0 :         return py_aipMasters;
   17605             : }
   17606             : 
   17607           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_aipMasters(PyObject *py_obj, PyObject *value, void *closure)
   17608             : {
   17609           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   17610           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipMasters));
   17611           0 :         if (value == NULL) {
   17612           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipMasters");
   17613           0 :                 return -1;
   17614             :         }
   17615           0 :         if (value == Py_None) {
   17616           0 :                 object->aipMasters = NULL;
   17617             :         } else {
   17618           0 :                 object->aipMasters = NULL;
   17619           0 :                 PY_CHECK_TYPE(&DNS_ADDR_ARRAY_Type, value, return -1;);
   17620           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   17621           0 :                         PyErr_NoMemory();
   17622           0 :                         return -1;
   17623             :                 }
   17624           0 :                 object->aipMasters = (struct DNS_ADDR_ARRAY *)pytalloc_get_ptr(value);
   17625             :         }
   17626           0 :         return 0;
   17627             : }
   17628             : 
   17629          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_fSecureSecondaries(PyObject *obj, void *closure)
   17630             : {
   17631          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   17632           0 :         PyObject *py_fSecureSecondaries;
   17633          17 :         py_fSecureSecondaries = PyLong_FromUnsignedLongLong((uint32_t)(object->fSecureSecondaries));
   17634          17 :         return py_fSecureSecondaries;
   17635             : }
   17636             : 
   17637           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_fSecureSecondaries(PyObject *py_obj, PyObject *value, void *closure)
   17638             : {
   17639           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   17640           0 :         if (value == NULL) {
   17641           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fSecureSecondaries");
   17642           0 :                 return -1;
   17643             :         }
   17644             :         {
   17645           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fSecureSecondaries));
   17646           0 :                 if (PyLong_Check(value)) {
   17647           0 :                         unsigned long long test_var;
   17648           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   17649           0 :                         if (PyErr_Occurred() != NULL) {
   17650           0 :                                 return -1;
   17651             :                         }
   17652           0 :                         if (test_var > uint_max) {
   17653           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   17654             :                                   PyLong_Type.tp_name, uint_max, test_var);
   17655           0 :                                 return -1;
   17656             :                         }
   17657           0 :                         object->fSecureSecondaries = test_var;
   17658             :                 } else {
   17659           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   17660             :                           PyLong_Type.tp_name);
   17661           0 :                         return -1;
   17662             :                 }
   17663             :         }
   17664           0 :         return 0;
   17665             : }
   17666             : 
   17667          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_fNotifyLevel(PyObject *obj, void *closure)
   17668             : {
   17669          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   17670           0 :         PyObject *py_fNotifyLevel;
   17671          17 :         py_fNotifyLevel = PyLong_FromUnsignedLongLong((uint32_t)(object->fNotifyLevel));
   17672          17 :         return py_fNotifyLevel;
   17673             : }
   17674             : 
   17675           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_fNotifyLevel(PyObject *py_obj, PyObject *value, void *closure)
   17676             : {
   17677           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   17678           0 :         if (value == NULL) {
   17679           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fNotifyLevel");
   17680           0 :                 return -1;
   17681             :         }
   17682             :         {
   17683           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fNotifyLevel));
   17684           0 :                 if (PyLong_Check(value)) {
   17685           0 :                         unsigned long long test_var;
   17686           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   17687           0 :                         if (PyErr_Occurred() != NULL) {
   17688           0 :                                 return -1;
   17689             :                         }
   17690           0 :                         if (test_var > uint_max) {
   17691           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   17692             :                                   PyLong_Type.tp_name, uint_max, test_var);
   17693           0 :                                 return -1;
   17694             :                         }
   17695           0 :                         object->fNotifyLevel = test_var;
   17696             :                 } else {
   17697           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   17698             :                           PyLong_Type.tp_name);
   17699           0 :                         return -1;
   17700             :                 }
   17701             :         }
   17702           0 :         return 0;
   17703             : }
   17704             : 
   17705          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_aipSecondaries(PyObject *obj, void *closure)
   17706             : {
   17707          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   17708           0 :         PyObject *py_aipSecondaries;
   17709          17 :         if (object->aipSecondaries == NULL) {
   17710          17 :                 Py_RETURN_NONE;
   17711             :         }
   17712           0 :         if (object->aipSecondaries == NULL) {
   17713           0 :                 py_aipSecondaries = Py_None;
   17714           0 :                 Py_INCREF(py_aipSecondaries);
   17715             :         } else {
   17716           0 :                 py_aipSecondaries = pytalloc_reference_ex(&DNS_ADDR_ARRAY_Type, object->aipSecondaries, object->aipSecondaries);
   17717             :         }
   17718           0 :         return py_aipSecondaries;
   17719             : }
   17720             : 
   17721           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_aipSecondaries(PyObject *py_obj, PyObject *value, void *closure)
   17722             : {
   17723           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   17724           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipSecondaries));
   17725           0 :         if (value == NULL) {
   17726           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipSecondaries");
   17727           0 :                 return -1;
   17728             :         }
   17729           0 :         if (value == Py_None) {
   17730           0 :                 object->aipSecondaries = NULL;
   17731             :         } else {
   17732           0 :                 object->aipSecondaries = NULL;
   17733           0 :                 PY_CHECK_TYPE(&DNS_ADDR_ARRAY_Type, value, return -1;);
   17734           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   17735           0 :                         PyErr_NoMemory();
   17736           0 :                         return -1;
   17737             :                 }
   17738           0 :                 object->aipSecondaries = (struct DNS_ADDR_ARRAY *)pytalloc_get_ptr(value);
   17739             :         }
   17740           0 :         return 0;
   17741             : }
   17742             : 
   17743          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_aipNotify(PyObject *obj, void *closure)
   17744             : {
   17745          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   17746           0 :         PyObject *py_aipNotify;
   17747          17 :         if (object->aipNotify == NULL) {
   17748          17 :                 Py_RETURN_NONE;
   17749             :         }
   17750           0 :         if (object->aipNotify == NULL) {
   17751           0 :                 py_aipNotify = Py_None;
   17752           0 :                 Py_INCREF(py_aipNotify);
   17753             :         } else {
   17754           0 :                 py_aipNotify = pytalloc_reference_ex(&DNS_ADDR_ARRAY_Type, object->aipNotify, object->aipNotify);
   17755             :         }
   17756           0 :         return py_aipNotify;
   17757             : }
   17758             : 
   17759           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_aipNotify(PyObject *py_obj, PyObject *value, void *closure)
   17760             : {
   17761           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   17762           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipNotify));
   17763           0 :         if (value == NULL) {
   17764           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipNotify");
   17765           0 :                 return -1;
   17766             :         }
   17767           0 :         if (value == Py_None) {
   17768           0 :                 object->aipNotify = NULL;
   17769             :         } else {
   17770           0 :                 object->aipNotify = NULL;
   17771           0 :                 PY_CHECK_TYPE(&DNS_ADDR_ARRAY_Type, value, return -1;);
   17772           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   17773           0 :                         PyErr_NoMemory();
   17774           0 :                         return -1;
   17775             :                 }
   17776           0 :                 object->aipNotify = (struct DNS_ADDR_ARRAY *)pytalloc_get_ptr(value);
   17777             :         }
   17778           0 :         return 0;
   17779             : }
   17780             : 
   17781          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_fUseWins(PyObject *obj, void *closure)
   17782             : {
   17783          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   17784           0 :         PyObject *py_fUseWins;
   17785          17 :         py_fUseWins = PyLong_FromUnsignedLongLong((uint32_t)(object->fUseWins));
   17786          17 :         return py_fUseWins;
   17787             : }
   17788             : 
   17789           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_fUseWins(PyObject *py_obj, PyObject *value, void *closure)
   17790             : {
   17791           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   17792           0 :         if (value == NULL) {
   17793           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fUseWins");
   17794           0 :                 return -1;
   17795             :         }
   17796             :         {
   17797           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fUseWins));
   17798           0 :                 if (PyLong_Check(value)) {
   17799           0 :                         unsigned long long test_var;
   17800           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   17801           0 :                         if (PyErr_Occurred() != NULL) {
   17802           0 :                                 return -1;
   17803             :                         }
   17804           0 :                         if (test_var > uint_max) {
   17805           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   17806             :                                   PyLong_Type.tp_name, uint_max, test_var);
   17807           0 :                                 return -1;
   17808             :                         }
   17809           0 :                         object->fUseWins = test_var;
   17810             :                 } else {
   17811           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   17812             :                           PyLong_Type.tp_name);
   17813           0 :                         return -1;
   17814             :                 }
   17815             :         }
   17816           0 :         return 0;
   17817             : }
   17818             : 
   17819          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_fUseNbstat(PyObject *obj, void *closure)
   17820             : {
   17821          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   17822           0 :         PyObject *py_fUseNbstat;
   17823          17 :         py_fUseNbstat = PyLong_FromUnsignedLongLong((uint32_t)(object->fUseNbstat));
   17824          17 :         return py_fUseNbstat;
   17825             : }
   17826             : 
   17827           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_fUseNbstat(PyObject *py_obj, PyObject *value, void *closure)
   17828             : {
   17829           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   17830           0 :         if (value == NULL) {
   17831           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fUseNbstat");
   17832           0 :                 return -1;
   17833             :         }
   17834             :         {
   17835           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fUseNbstat));
   17836           0 :                 if (PyLong_Check(value)) {
   17837           0 :                         unsigned long long test_var;
   17838           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   17839           0 :                         if (PyErr_Occurred() != NULL) {
   17840           0 :                                 return -1;
   17841             :                         }
   17842           0 :                         if (test_var > uint_max) {
   17843           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   17844             :                                   PyLong_Type.tp_name, uint_max, test_var);
   17845           0 :                                 return -1;
   17846             :                         }
   17847           0 :                         object->fUseNbstat = test_var;
   17848             :                 } else {
   17849           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   17850             :                           PyLong_Type.tp_name);
   17851           0 :                         return -1;
   17852             :                 }
   17853             :         }
   17854           0 :         return 0;
   17855             : }
   17856             : 
   17857          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_fAging(PyObject *obj, void *closure)
   17858             : {
   17859          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   17860           0 :         PyObject *py_fAging;
   17861          17 :         py_fAging = PyLong_FromUnsignedLongLong((uint32_t)(object->fAging));
   17862          17 :         return py_fAging;
   17863             : }
   17864             : 
   17865           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_fAging(PyObject *py_obj, PyObject *value, void *closure)
   17866             : {
   17867           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   17868           0 :         if (value == NULL) {
   17869           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAging");
   17870           0 :                 return -1;
   17871             :         }
   17872             :         {
   17873           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAging));
   17874           0 :                 if (PyLong_Check(value)) {
   17875           0 :                         unsigned long long test_var;
   17876           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   17877           0 :                         if (PyErr_Occurred() != NULL) {
   17878           0 :                                 return -1;
   17879             :                         }
   17880           0 :                         if (test_var > uint_max) {
   17881           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   17882             :                                   PyLong_Type.tp_name, uint_max, test_var);
   17883           0 :                                 return -1;
   17884             :                         }
   17885           0 :                         object->fAging = test_var;
   17886             :                 } else {
   17887           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   17888             :                           PyLong_Type.tp_name);
   17889           0 :                         return -1;
   17890             :                 }
   17891             :         }
   17892           0 :         return 0;
   17893             : }
   17894             : 
   17895          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_dwNoRefreshInterval(PyObject *obj, void *closure)
   17896             : {
   17897          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   17898           0 :         PyObject *py_dwNoRefreshInterval;
   17899          17 :         py_dwNoRefreshInterval = PyLong_FromUnsignedLongLong((uint32_t)(object->dwNoRefreshInterval));
   17900          17 :         return py_dwNoRefreshInterval;
   17901             : }
   17902             : 
   17903           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_dwNoRefreshInterval(PyObject *py_obj, PyObject *value, void *closure)
   17904             : {
   17905           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   17906           0 :         if (value == NULL) {
   17907           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwNoRefreshInterval");
   17908           0 :                 return -1;
   17909             :         }
   17910             :         {
   17911           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwNoRefreshInterval));
   17912           0 :                 if (PyLong_Check(value)) {
   17913           0 :                         unsigned long long test_var;
   17914           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   17915           0 :                         if (PyErr_Occurred() != NULL) {
   17916           0 :                                 return -1;
   17917             :                         }
   17918           0 :                         if (test_var > uint_max) {
   17919           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   17920             :                                   PyLong_Type.tp_name, uint_max, test_var);
   17921           0 :                                 return -1;
   17922             :                         }
   17923           0 :                         object->dwNoRefreshInterval = test_var;
   17924             :                 } else {
   17925           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   17926             :                           PyLong_Type.tp_name);
   17927           0 :                         return -1;
   17928             :                 }
   17929             :         }
   17930           0 :         return 0;
   17931             : }
   17932             : 
   17933          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_dwRefreshInterval(PyObject *obj, void *closure)
   17934             : {
   17935          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   17936           0 :         PyObject *py_dwRefreshInterval;
   17937          17 :         py_dwRefreshInterval = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRefreshInterval));
   17938          17 :         return py_dwRefreshInterval;
   17939             : }
   17940             : 
   17941           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_dwRefreshInterval(PyObject *py_obj, PyObject *value, void *closure)
   17942             : {
   17943           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   17944           0 :         if (value == NULL) {
   17945           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRefreshInterval");
   17946           0 :                 return -1;
   17947             :         }
   17948             :         {
   17949           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRefreshInterval));
   17950           0 :                 if (PyLong_Check(value)) {
   17951           0 :                         unsigned long long test_var;
   17952           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   17953           0 :                         if (PyErr_Occurred() != NULL) {
   17954           0 :                                 return -1;
   17955             :                         }
   17956           0 :                         if (test_var > uint_max) {
   17957           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   17958             :                                   PyLong_Type.tp_name, uint_max, test_var);
   17959           0 :                                 return -1;
   17960             :                         }
   17961           0 :                         object->dwRefreshInterval = test_var;
   17962             :                 } else {
   17963           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   17964             :                           PyLong_Type.tp_name);
   17965           0 :                         return -1;
   17966             :                 }
   17967             :         }
   17968           0 :         return 0;
   17969             : }
   17970             : 
   17971          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_dwAvailForScavengeTime(PyObject *obj, void *closure)
   17972             : {
   17973          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   17974           0 :         PyObject *py_dwAvailForScavengeTime;
   17975          17 :         py_dwAvailForScavengeTime = PyLong_FromUnsignedLongLong((uint32_t)(object->dwAvailForScavengeTime));
   17976          17 :         return py_dwAvailForScavengeTime;
   17977             : }
   17978             : 
   17979           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_dwAvailForScavengeTime(PyObject *py_obj, PyObject *value, void *closure)
   17980             : {
   17981           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   17982           0 :         if (value == NULL) {
   17983           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwAvailForScavengeTime");
   17984           0 :                 return -1;
   17985             :         }
   17986             :         {
   17987           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwAvailForScavengeTime));
   17988           0 :                 if (PyLong_Check(value)) {
   17989           0 :                         unsigned long long test_var;
   17990           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   17991           0 :                         if (PyErr_Occurred() != NULL) {
   17992           0 :                                 return -1;
   17993             :                         }
   17994           0 :                         if (test_var > uint_max) {
   17995           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   17996             :                                   PyLong_Type.tp_name, uint_max, test_var);
   17997           0 :                                 return -1;
   17998             :                         }
   17999           0 :                         object->dwAvailForScavengeTime = test_var;
   18000             :                 } else {
   18001           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   18002             :                           PyLong_Type.tp_name);
   18003           0 :                         return -1;
   18004             :                 }
   18005             :         }
   18006           0 :         return 0;
   18007             : }
   18008             : 
   18009          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_aipScavengeServers(PyObject *obj, void *closure)
   18010             : {
   18011          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   18012           0 :         PyObject *py_aipScavengeServers;
   18013          17 :         if (object->aipScavengeServers == NULL) {
   18014          17 :                 Py_RETURN_NONE;
   18015             :         }
   18016           0 :         if (object->aipScavengeServers == NULL) {
   18017           0 :                 py_aipScavengeServers = Py_None;
   18018           0 :                 Py_INCREF(py_aipScavengeServers);
   18019             :         } else {
   18020           0 :                 py_aipScavengeServers = pytalloc_reference_ex(&DNS_ADDR_ARRAY_Type, object->aipScavengeServers, object->aipScavengeServers);
   18021             :         }
   18022           0 :         return py_aipScavengeServers;
   18023             : }
   18024             : 
   18025           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_aipScavengeServers(PyObject *py_obj, PyObject *value, void *closure)
   18026             : {
   18027           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   18028           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipScavengeServers));
   18029           0 :         if (value == NULL) {
   18030           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipScavengeServers");
   18031           0 :                 return -1;
   18032             :         }
   18033           0 :         if (value == Py_None) {
   18034           0 :                 object->aipScavengeServers = NULL;
   18035             :         } else {
   18036           0 :                 object->aipScavengeServers = NULL;
   18037           0 :                 PY_CHECK_TYPE(&DNS_ADDR_ARRAY_Type, value, return -1;);
   18038           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   18039           0 :                         PyErr_NoMemory();
   18040           0 :                         return -1;
   18041             :                 }
   18042           0 :                 object->aipScavengeServers = (struct DNS_ADDR_ARRAY *)pytalloc_get_ptr(value);
   18043             :         }
   18044           0 :         return 0;
   18045             : }
   18046             : 
   18047          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_dwForwarderTimeout(PyObject *obj, void *closure)
   18048             : {
   18049          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   18050           0 :         PyObject *py_dwForwarderTimeout;
   18051          17 :         py_dwForwarderTimeout = PyLong_FromUnsignedLongLong((uint32_t)(object->dwForwarderTimeout));
   18052          17 :         return py_dwForwarderTimeout;
   18053             : }
   18054             : 
   18055           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_dwForwarderTimeout(PyObject *py_obj, PyObject *value, void *closure)
   18056             : {
   18057           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   18058           0 :         if (value == NULL) {
   18059           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwForwarderTimeout");
   18060           0 :                 return -1;
   18061             :         }
   18062             :         {
   18063           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwForwarderTimeout));
   18064           0 :                 if (PyLong_Check(value)) {
   18065           0 :                         unsigned long long test_var;
   18066           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   18067           0 :                         if (PyErr_Occurred() != NULL) {
   18068           0 :                                 return -1;
   18069             :                         }
   18070           0 :                         if (test_var > uint_max) {
   18071           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   18072             :                                   PyLong_Type.tp_name, uint_max, test_var);
   18073           0 :                                 return -1;
   18074             :                         }
   18075           0 :                         object->dwForwarderTimeout = test_var;
   18076             :                 } else {
   18077           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   18078             :                           PyLong_Type.tp_name);
   18079           0 :                         return -1;
   18080             :                 }
   18081             :         }
   18082           0 :         return 0;
   18083             : }
   18084             : 
   18085          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_fForwarderSlave(PyObject *obj, void *closure)
   18086             : {
   18087          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   18088           0 :         PyObject *py_fForwarderSlave;
   18089          17 :         py_fForwarderSlave = PyLong_FromUnsignedLongLong((uint32_t)(object->fForwarderSlave));
   18090          17 :         return py_fForwarderSlave;
   18091             : }
   18092             : 
   18093           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_fForwarderSlave(PyObject *py_obj, PyObject *value, void *closure)
   18094             : {
   18095           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   18096           0 :         if (value == NULL) {
   18097           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fForwarderSlave");
   18098           0 :                 return -1;
   18099             :         }
   18100             :         {
   18101           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fForwarderSlave));
   18102           0 :                 if (PyLong_Check(value)) {
   18103           0 :                         unsigned long long test_var;
   18104           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   18105           0 :                         if (PyErr_Occurred() != NULL) {
   18106           0 :                                 return -1;
   18107             :                         }
   18108           0 :                         if (test_var > uint_max) {
   18109           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   18110             :                                   PyLong_Type.tp_name, uint_max, test_var);
   18111           0 :                                 return -1;
   18112             :                         }
   18113           0 :                         object->fForwarderSlave = test_var;
   18114             :                 } else {
   18115           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   18116             :                           PyLong_Type.tp_name);
   18117           0 :                         return -1;
   18118             :                 }
   18119             :         }
   18120           0 :         return 0;
   18121             : }
   18122             : 
   18123          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_aipLocalMasters(PyObject *obj, void *closure)
   18124             : {
   18125          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   18126           0 :         PyObject *py_aipLocalMasters;
   18127          17 :         if (object->aipLocalMasters == NULL) {
   18128          17 :                 Py_RETURN_NONE;
   18129             :         }
   18130           0 :         if (object->aipLocalMasters == NULL) {
   18131           0 :                 py_aipLocalMasters = Py_None;
   18132           0 :                 Py_INCREF(py_aipLocalMasters);
   18133             :         } else {
   18134           0 :                 py_aipLocalMasters = pytalloc_reference_ex(&DNS_ADDR_ARRAY_Type, object->aipLocalMasters, object->aipLocalMasters);
   18135             :         }
   18136           0 :         return py_aipLocalMasters;
   18137             : }
   18138             : 
   18139           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_aipLocalMasters(PyObject *py_obj, PyObject *value, void *closure)
   18140             : {
   18141           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   18142           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipLocalMasters));
   18143           0 :         if (value == NULL) {
   18144           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipLocalMasters");
   18145           0 :                 return -1;
   18146             :         }
   18147           0 :         if (value == Py_None) {
   18148           0 :                 object->aipLocalMasters = NULL;
   18149             :         } else {
   18150           0 :                 object->aipLocalMasters = NULL;
   18151           0 :                 PY_CHECK_TYPE(&DNS_ADDR_ARRAY_Type, value, return -1;);
   18152           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   18153           0 :                         PyErr_NoMemory();
   18154           0 :                         return -1;
   18155             :                 }
   18156           0 :                 object->aipLocalMasters = (struct DNS_ADDR_ARRAY *)pytalloc_get_ptr(value);
   18157             :         }
   18158           0 :         return 0;
   18159             : }
   18160             : 
   18161          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_dwDpFlags(PyObject *obj, void *closure)
   18162             : {
   18163          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   18164           0 :         PyObject *py_dwDpFlags;
   18165          17 :         py_dwDpFlags = PyLong_FromUnsignedLongLong((uint32_t)(object->dwDpFlags));
   18166          17 :         return py_dwDpFlags;
   18167             : }
   18168             : 
   18169           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_dwDpFlags(PyObject *py_obj, PyObject *value, void *closure)
   18170             : {
   18171           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   18172           0 :         if (value == NULL) {
   18173           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwDpFlags");
   18174           0 :                 return -1;
   18175             :         }
   18176             :         {
   18177           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwDpFlags));
   18178           0 :                 if (PyLong_Check(value)) {
   18179           0 :                         unsigned long long test_var;
   18180           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   18181           0 :                         if (PyErr_Occurred() != NULL) {
   18182           0 :                                 return -1;
   18183             :                         }
   18184           0 :                         if (test_var > uint_max) {
   18185           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   18186             :                                   PyLong_Type.tp_name, uint_max, test_var);
   18187           0 :                                 return -1;
   18188             :                         }
   18189           0 :                         object->dwDpFlags = test_var;
   18190             :                 } else {
   18191           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   18192             :                           PyLong_Type.tp_name);
   18193           0 :                         return -1;
   18194             :                 }
   18195             :         }
   18196           0 :         return 0;
   18197             : }
   18198             : 
   18199          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_pszDpFqdn(PyObject *obj, void *closure)
   18200             : {
   18201          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   18202           0 :         PyObject *py_pszDpFqdn;
   18203          17 :         if (object->pszDpFqdn == NULL) {
   18204           0 :                 Py_RETURN_NONE;
   18205             :         }
   18206          17 :         if (object->pszDpFqdn == NULL) {
   18207           0 :                 py_pszDpFqdn = Py_None;
   18208           0 :                 Py_INCREF(py_pszDpFqdn);
   18209             :         } else {
   18210          17 :                 if (object->pszDpFqdn == NULL) {
   18211           0 :                         py_pszDpFqdn = Py_None;
   18212           0 :                         Py_INCREF(py_pszDpFqdn);
   18213             :                 } else {
   18214          17 :                         py_pszDpFqdn = PyUnicode_Decode(object->pszDpFqdn, strlen(object->pszDpFqdn), "utf-8", "ignore");
   18215             :                 }
   18216             :         }
   18217          17 :         return py_pszDpFqdn;
   18218             : }
   18219             : 
   18220           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_pszDpFqdn(PyObject *py_obj, PyObject *value, void *closure)
   18221             : {
   18222           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   18223           0 :         if (value == NULL) {
   18224           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszDpFqdn");
   18225           0 :                 return -1;
   18226             :         }
   18227           0 :         if (value == Py_None) {
   18228           0 :                 object->pszDpFqdn = NULL;
   18229             :         } else {
   18230           0 :                 object->pszDpFqdn = NULL;
   18231             :                 {
   18232           0 :                         const char *test_str;
   18233           0 :                         const char *talloc_str;
   18234           0 :                         PyObject *unicode = NULL;
   18235           0 :                         if (PyUnicode_Check(value)) {
   18236           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   18237           0 :                                 if (unicode == NULL) {
   18238           0 :                                         return -1;
   18239             :                                 }
   18240           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   18241           0 :                         } else if (PyBytes_Check(value)) {
   18242           0 :                                 test_str = PyBytes_AS_STRING(value);
   18243             :                         } else {
   18244           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   18245           0 :                                 return -1;
   18246             :                         }
   18247           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   18248           0 :                         if (unicode != NULL) {
   18249           0 :                                 Py_DECREF(unicode);
   18250             :                         }
   18251           0 :                         if (talloc_str == NULL) {
   18252           0 :                                 PyErr_NoMemory();
   18253           0 :                                 return -1;
   18254             :                         }
   18255           0 :                         object->pszDpFqdn = talloc_str;
   18256             :                 }
   18257             :         }
   18258           0 :         return 0;
   18259             : }
   18260             : 
   18261          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_pwszZoneDn(PyObject *obj, void *closure)
   18262             : {
   18263          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   18264           0 :         PyObject *py_pwszZoneDn;
   18265          17 :         if (object->pwszZoneDn == NULL) {
   18266           0 :                 Py_RETURN_NONE;
   18267             :         }
   18268          17 :         if (object->pwszZoneDn == NULL) {
   18269           0 :                 py_pwszZoneDn = Py_None;
   18270           0 :                 Py_INCREF(py_pwszZoneDn);
   18271             :         } else {
   18272          17 :                 if (object->pwszZoneDn == NULL) {
   18273           0 :                         py_pwszZoneDn = Py_None;
   18274           0 :                         Py_INCREF(py_pwszZoneDn);
   18275             :                 } else {
   18276          17 :                         py_pwszZoneDn = PyUnicode_Decode(object->pwszZoneDn, strlen(object->pwszZoneDn), "utf-8", "ignore");
   18277             :                 }
   18278             :         }
   18279          17 :         return py_pwszZoneDn;
   18280             : }
   18281             : 
   18282           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_pwszZoneDn(PyObject *py_obj, PyObject *value, void *closure)
   18283             : {
   18284           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   18285           0 :         if (value == NULL) {
   18286           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pwszZoneDn");
   18287           0 :                 return -1;
   18288             :         }
   18289           0 :         if (value == Py_None) {
   18290           0 :                 object->pwszZoneDn = NULL;
   18291             :         } else {
   18292           0 :                 object->pwszZoneDn = NULL;
   18293             :                 {
   18294           0 :                         const char *test_str;
   18295           0 :                         const char *talloc_str;
   18296           0 :                         PyObject *unicode = NULL;
   18297           0 :                         if (PyUnicode_Check(value)) {
   18298           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   18299           0 :                                 if (unicode == NULL) {
   18300           0 :                                         return -1;
   18301             :                                 }
   18302           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   18303           0 :                         } else if (PyBytes_Check(value)) {
   18304           0 :                                 test_str = PyBytes_AS_STRING(value);
   18305             :                         } else {
   18306           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   18307           0 :                                 return -1;
   18308             :                         }
   18309           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   18310           0 :                         if (unicode != NULL) {
   18311           0 :                                 Py_DECREF(unicode);
   18312             :                         }
   18313           0 :                         if (talloc_str == NULL) {
   18314           0 :                                 PyErr_NoMemory();
   18315           0 :                                 return -1;
   18316             :                         }
   18317           0 :                         object->pwszZoneDn = talloc_str;
   18318             :                 }
   18319             :         }
   18320           0 :         return 0;
   18321             : }
   18322             : 
   18323          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_dwLastSuccessfulSoaCheck(PyObject *obj, void *closure)
   18324             : {
   18325          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   18326           0 :         PyObject *py_dwLastSuccessfulSoaCheck;
   18327          17 :         py_dwLastSuccessfulSoaCheck = PyLong_FromUnsignedLongLong((uint32_t)(object->dwLastSuccessfulSoaCheck));
   18328          17 :         return py_dwLastSuccessfulSoaCheck;
   18329             : }
   18330             : 
   18331           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_dwLastSuccessfulSoaCheck(PyObject *py_obj, PyObject *value, void *closure)
   18332             : {
   18333           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   18334           0 :         if (value == NULL) {
   18335           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwLastSuccessfulSoaCheck");
   18336           0 :                 return -1;
   18337             :         }
   18338             :         {
   18339           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwLastSuccessfulSoaCheck));
   18340           0 :                 if (PyLong_Check(value)) {
   18341           0 :                         unsigned long long test_var;
   18342           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   18343           0 :                         if (PyErr_Occurred() != NULL) {
   18344           0 :                                 return -1;
   18345             :                         }
   18346           0 :                         if (test_var > uint_max) {
   18347           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   18348             :                                   PyLong_Type.tp_name, uint_max, test_var);
   18349           0 :                                 return -1;
   18350             :                         }
   18351           0 :                         object->dwLastSuccessfulSoaCheck = test_var;
   18352             :                 } else {
   18353           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   18354             :                           PyLong_Type.tp_name);
   18355           0 :                         return -1;
   18356             :                 }
   18357             :         }
   18358           0 :         return 0;
   18359             : }
   18360             : 
   18361          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_dwLastSuccessfulXfr(PyObject *obj, void *closure)
   18362             : {
   18363          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   18364           0 :         PyObject *py_dwLastSuccessfulXfr;
   18365          17 :         py_dwLastSuccessfulXfr = PyLong_FromUnsignedLongLong((uint32_t)(object->dwLastSuccessfulXfr));
   18366          17 :         return py_dwLastSuccessfulXfr;
   18367             : }
   18368             : 
   18369           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_dwLastSuccessfulXfr(PyObject *py_obj, PyObject *value, void *closure)
   18370             : {
   18371           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   18372           0 :         if (value == NULL) {
   18373           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwLastSuccessfulXfr");
   18374           0 :                 return -1;
   18375             :         }
   18376             :         {
   18377           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwLastSuccessfulXfr));
   18378           0 :                 if (PyLong_Check(value)) {
   18379           0 :                         unsigned long long test_var;
   18380           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   18381           0 :                         if (PyErr_Occurred() != NULL) {
   18382           0 :                                 return -1;
   18383             :                         }
   18384           0 :                         if (test_var > uint_max) {
   18385           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   18386             :                                   PyLong_Type.tp_name, uint_max, test_var);
   18387           0 :                                 return -1;
   18388             :                         }
   18389           0 :                         object->dwLastSuccessfulXfr = test_var;
   18390             :                 } else {
   18391           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   18392             :                           PyLong_Type.tp_name);
   18393           0 :                         return -1;
   18394             :                 }
   18395             :         }
   18396           0 :         return 0;
   18397             : }
   18398             : 
   18399          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_fQueuedForBackgroundLoad(PyObject *obj, void *closure)
   18400             : {
   18401          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   18402           0 :         PyObject *py_fQueuedForBackgroundLoad;
   18403          17 :         py_fQueuedForBackgroundLoad = PyLong_FromUnsignedLongLong((uint32_t)(object->fQueuedForBackgroundLoad));
   18404          17 :         return py_fQueuedForBackgroundLoad;
   18405             : }
   18406             : 
   18407           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_fQueuedForBackgroundLoad(PyObject *py_obj, PyObject *value, void *closure)
   18408             : {
   18409           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   18410           0 :         if (value == NULL) {
   18411           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fQueuedForBackgroundLoad");
   18412           0 :                 return -1;
   18413             :         }
   18414             :         {
   18415           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fQueuedForBackgroundLoad));
   18416           0 :                 if (PyLong_Check(value)) {
   18417           0 :                         unsigned long long test_var;
   18418           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   18419           0 :                         if (PyErr_Occurred() != NULL) {
   18420           0 :                                 return -1;
   18421             :                         }
   18422           0 :                         if (test_var > uint_max) {
   18423           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   18424             :                                   PyLong_Type.tp_name, uint_max, test_var);
   18425           0 :                                 return -1;
   18426             :                         }
   18427           0 :                         object->fQueuedForBackgroundLoad = test_var;
   18428             :                 } else {
   18429           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   18430             :                           PyLong_Type.tp_name);
   18431           0 :                         return -1;
   18432             :                 }
   18433             :         }
   18434           0 :         return 0;
   18435             : }
   18436             : 
   18437          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_fBackgroundLoadInProgress(PyObject *obj, void *closure)
   18438             : {
   18439          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   18440           0 :         PyObject *py_fBackgroundLoadInProgress;
   18441          17 :         py_fBackgroundLoadInProgress = PyLong_FromUnsignedLongLong((uint32_t)(object->fBackgroundLoadInProgress));
   18442          17 :         return py_fBackgroundLoadInProgress;
   18443             : }
   18444             : 
   18445           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_fBackgroundLoadInProgress(PyObject *py_obj, PyObject *value, void *closure)
   18446             : {
   18447           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   18448           0 :         if (value == NULL) {
   18449           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fBackgroundLoadInProgress");
   18450           0 :                 return -1;
   18451             :         }
   18452             :         {
   18453           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fBackgroundLoadInProgress));
   18454           0 :                 if (PyLong_Check(value)) {
   18455           0 :                         unsigned long long test_var;
   18456           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   18457           0 :                         if (PyErr_Occurred() != NULL) {
   18458           0 :                                 return -1;
   18459             :                         }
   18460           0 :                         if (test_var > uint_max) {
   18461           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   18462             :                                   PyLong_Type.tp_name, uint_max, test_var);
   18463           0 :                                 return -1;
   18464             :                         }
   18465           0 :                         object->fBackgroundLoadInProgress = test_var;
   18466             :                 } else {
   18467           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   18468             :                           PyLong_Type.tp_name);
   18469           0 :                         return -1;
   18470             :                 }
   18471             :         }
   18472           0 :         return 0;
   18473             : }
   18474             : 
   18475          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_fReadOnlyZone(PyObject *obj, void *closure)
   18476             : {
   18477          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   18478           0 :         PyObject *py_fReadOnlyZone;
   18479          17 :         py_fReadOnlyZone = PyLong_FromUnsignedLongLong((uint32_t)(object->fReadOnlyZone));
   18480          17 :         return py_fReadOnlyZone;
   18481             : }
   18482             : 
   18483           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_fReadOnlyZone(PyObject *py_obj, PyObject *value, void *closure)
   18484             : {
   18485           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   18486           0 :         if (value == NULL) {
   18487           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fReadOnlyZone");
   18488           0 :                 return -1;
   18489             :         }
   18490             :         {
   18491           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fReadOnlyZone));
   18492           0 :                 if (PyLong_Check(value)) {
   18493           0 :                         unsigned long long test_var;
   18494           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   18495           0 :                         if (PyErr_Occurred() != NULL) {
   18496           0 :                                 return -1;
   18497             :                         }
   18498           0 :                         if (test_var > uint_max) {
   18499           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   18500             :                                   PyLong_Type.tp_name, uint_max, test_var);
   18501           0 :                                 return -1;
   18502             :                         }
   18503           0 :                         object->fReadOnlyZone = test_var;
   18504             :                 } else {
   18505           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   18506             :                           PyLong_Type.tp_name);
   18507           0 :                         return -1;
   18508             :                 }
   18509             :         }
   18510           0 :         return 0;
   18511             : }
   18512             : 
   18513          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_dwLastXfrAttempt(PyObject *obj, void *closure)
   18514             : {
   18515          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   18516           0 :         PyObject *py_dwLastXfrAttempt;
   18517          17 :         py_dwLastXfrAttempt = PyLong_FromUnsignedLongLong((uint32_t)(object->dwLastXfrAttempt));
   18518          17 :         return py_dwLastXfrAttempt;
   18519             : }
   18520             : 
   18521           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_dwLastXfrAttempt(PyObject *py_obj, PyObject *value, void *closure)
   18522             : {
   18523           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   18524           0 :         if (value == NULL) {
   18525           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwLastXfrAttempt");
   18526           0 :                 return -1;
   18527             :         }
   18528             :         {
   18529           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwLastXfrAttempt));
   18530           0 :                 if (PyLong_Check(value)) {
   18531           0 :                         unsigned long long test_var;
   18532           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   18533           0 :                         if (PyErr_Occurred() != NULL) {
   18534           0 :                                 return -1;
   18535             :                         }
   18536           0 :                         if (test_var > uint_max) {
   18537           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   18538             :                                   PyLong_Type.tp_name, uint_max, test_var);
   18539           0 :                                 return -1;
   18540             :                         }
   18541           0 :                         object->dwLastXfrAttempt = test_var;
   18542             :                 } else {
   18543           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   18544             :                           PyLong_Type.tp_name);
   18545           0 :                         return -1;
   18546             :                 }
   18547             :         }
   18548           0 :         return 0;
   18549             : }
   18550             : 
   18551          17 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_get_dwLastXfrResult(PyObject *obj, void *closure)
   18552             : {
   18553          17 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   18554           0 :         PyObject *py_dwLastXfrResult;
   18555          17 :         py_dwLastXfrResult = PyLong_FromUnsignedLongLong((uint32_t)(object->dwLastXfrResult));
   18556          17 :         return py_dwLastXfrResult;
   18557             : }
   18558             : 
   18559           0 : static int py_DNS_RPC_ZONE_INFO_LONGHORN_set_dwLastXfrResult(PyObject *py_obj, PyObject *value, void *closure)
   18560             : {
   18561           0 :         struct DNS_RPC_ZONE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   18562           0 :         if (value == NULL) {
   18563           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwLastXfrResult");
   18564           0 :                 return -1;
   18565             :         }
   18566             :         {
   18567           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwLastXfrResult));
   18568           0 :                 if (PyLong_Check(value)) {
   18569           0 :                         unsigned long long test_var;
   18570           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   18571           0 :                         if (PyErr_Occurred() != NULL) {
   18572           0 :                                 return -1;
   18573             :                         }
   18574           0 :                         if (test_var > uint_max) {
   18575           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   18576             :                                   PyLong_Type.tp_name, uint_max, test_var);
   18577           0 :                                 return -1;
   18578             :                         }
   18579           0 :                         object->dwLastXfrResult = test_var;
   18580             :                 } else {
   18581           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   18582             :                           PyLong_Type.tp_name);
   18583           0 :                         return -1;
   18584             :                 }
   18585             :         }
   18586           0 :         return 0;
   18587             : }
   18588             : 
   18589             : static PyGetSetDef py_DNS_RPC_ZONE_INFO_LONGHORN_getsetters[] = {
   18590             :         {
   18591             :                 .name = discard_const_p(char, "dwRpcStructureVersion"),
   18592             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_dwRpcStructureVersion,
   18593             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_dwRpcStructureVersion,
   18594             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   18595             :         },
   18596             :         {
   18597             :                 .name = discard_const_p(char, "dwReserved0"),
   18598             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_dwReserved0,
   18599             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_dwReserved0,
   18600             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   18601             :         },
   18602             :         {
   18603             :                 .name = discard_const_p(char, "pszZoneName"),
   18604             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_pszZoneName,
   18605             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_pszZoneName,
   18606             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   18607             :         },
   18608             :         {
   18609             :                 .name = discard_const_p(char, "dwZoneType"),
   18610             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_dwZoneType,
   18611             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_dwZoneType,
   18612             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   18613             :         },
   18614             :         {
   18615             :                 .name = discard_const_p(char, "fReverse"),
   18616             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_fReverse,
   18617             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_fReverse,
   18618             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   18619             :         },
   18620             :         {
   18621             :                 .name = discard_const_p(char, "fAllowUpdate"),
   18622             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_fAllowUpdate,
   18623             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_fAllowUpdate,
   18624             :                 .doc = discard_const_p(char, "PIDL-generated element of base type dns_zone_update")
   18625             :         },
   18626             :         {
   18627             :                 .name = discard_const_p(char, "fPaused"),
   18628             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_fPaused,
   18629             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_fPaused,
   18630             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   18631             :         },
   18632             :         {
   18633             :                 .name = discard_const_p(char, "fShutdown"),
   18634             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_fShutdown,
   18635             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_fShutdown,
   18636             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   18637             :         },
   18638             :         {
   18639             :                 .name = discard_const_p(char, "fAutoCreated"),
   18640             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_fAutoCreated,
   18641             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_fAutoCreated,
   18642             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   18643             :         },
   18644             :         {
   18645             :                 .name = discard_const_p(char, "fUseDatabase"),
   18646             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_fUseDatabase,
   18647             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_fUseDatabase,
   18648             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   18649             :         },
   18650             :         {
   18651             :                 .name = discard_const_p(char, "pszDataFile"),
   18652             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_pszDataFile,
   18653             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_pszDataFile,
   18654             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   18655             :         },
   18656             :         {
   18657             :                 .name = discard_const_p(char, "aipMasters"),
   18658             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_aipMasters,
   18659             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_aipMasters,
   18660             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ADDR_ARRAY")
   18661             :         },
   18662             :         {
   18663             :                 .name = discard_const_p(char, "fSecureSecondaries"),
   18664             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_fSecureSecondaries,
   18665             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_fSecureSecondaries,
   18666             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ZONE_SECONDARY_SECURITY")
   18667             :         },
   18668             :         {
   18669             :                 .name = discard_const_p(char, "fNotifyLevel"),
   18670             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_fNotifyLevel,
   18671             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_fNotifyLevel,
   18672             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ZONE_NOTIFY_LEVEL")
   18673             :         },
   18674             :         {
   18675             :                 .name = discard_const_p(char, "aipSecondaries"),
   18676             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_aipSecondaries,
   18677             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_aipSecondaries,
   18678             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ADDR_ARRAY")
   18679             :         },
   18680             :         {
   18681             :                 .name = discard_const_p(char, "aipNotify"),
   18682             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_aipNotify,
   18683             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_aipNotify,
   18684             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ADDR_ARRAY")
   18685             :         },
   18686             :         {
   18687             :                 .name = discard_const_p(char, "fUseWins"),
   18688             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_fUseWins,
   18689             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_fUseWins,
   18690             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   18691             :         },
   18692             :         {
   18693             :                 .name = discard_const_p(char, "fUseNbstat"),
   18694             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_fUseNbstat,
   18695             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_fUseNbstat,
   18696             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   18697             :         },
   18698             :         {
   18699             :                 .name = discard_const_p(char, "fAging"),
   18700             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_fAging,
   18701             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_fAging,
   18702             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   18703             :         },
   18704             :         {
   18705             :                 .name = discard_const_p(char, "dwNoRefreshInterval"),
   18706             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_dwNoRefreshInterval,
   18707             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_dwNoRefreshInterval,
   18708             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   18709             :         },
   18710             :         {
   18711             :                 .name = discard_const_p(char, "dwRefreshInterval"),
   18712             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_dwRefreshInterval,
   18713             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_dwRefreshInterval,
   18714             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   18715             :         },
   18716             :         {
   18717             :                 .name = discard_const_p(char, "dwAvailForScavengeTime"),
   18718             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_dwAvailForScavengeTime,
   18719             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_dwAvailForScavengeTime,
   18720             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   18721             :         },
   18722             :         {
   18723             :                 .name = discard_const_p(char, "aipScavengeServers"),
   18724             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_aipScavengeServers,
   18725             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_aipScavengeServers,
   18726             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ADDR_ARRAY")
   18727             :         },
   18728             :         {
   18729             :                 .name = discard_const_p(char, "dwForwarderTimeout"),
   18730             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_dwForwarderTimeout,
   18731             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_dwForwarderTimeout,
   18732             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   18733             :         },
   18734             :         {
   18735             :                 .name = discard_const_p(char, "fForwarderSlave"),
   18736             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_fForwarderSlave,
   18737             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_fForwarderSlave,
   18738             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   18739             :         },
   18740             :         {
   18741             :                 .name = discard_const_p(char, "aipLocalMasters"),
   18742             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_aipLocalMasters,
   18743             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_aipLocalMasters,
   18744             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ADDR_ARRAY")
   18745             :         },
   18746             :         {
   18747             :                 .name = discard_const_p(char, "dwDpFlags"),
   18748             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_dwDpFlags,
   18749             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_dwDpFlags,
   18750             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   18751             :         },
   18752             :         {
   18753             :                 .name = discard_const_p(char, "pszDpFqdn"),
   18754             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_pszDpFqdn,
   18755             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_pszDpFqdn,
   18756             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   18757             :         },
   18758             :         {
   18759             :                 .name = discard_const_p(char, "pwszZoneDn"),
   18760             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_pwszZoneDn,
   18761             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_pwszZoneDn,
   18762             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
   18763             :         },
   18764             :         {
   18765             :                 .name = discard_const_p(char, "dwLastSuccessfulSoaCheck"),
   18766             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_dwLastSuccessfulSoaCheck,
   18767             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_dwLastSuccessfulSoaCheck,
   18768             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   18769             :         },
   18770             :         {
   18771             :                 .name = discard_const_p(char, "dwLastSuccessfulXfr"),
   18772             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_dwLastSuccessfulXfr,
   18773             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_dwLastSuccessfulXfr,
   18774             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   18775             :         },
   18776             :         {
   18777             :                 .name = discard_const_p(char, "fQueuedForBackgroundLoad"),
   18778             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_fQueuedForBackgroundLoad,
   18779             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_fQueuedForBackgroundLoad,
   18780             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   18781             :         },
   18782             :         {
   18783             :                 .name = discard_const_p(char, "fBackgroundLoadInProgress"),
   18784             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_fBackgroundLoadInProgress,
   18785             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_fBackgroundLoadInProgress,
   18786             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   18787             :         },
   18788             :         {
   18789             :                 .name = discard_const_p(char, "fReadOnlyZone"),
   18790             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_fReadOnlyZone,
   18791             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_fReadOnlyZone,
   18792             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   18793             :         },
   18794             :         {
   18795             :                 .name = discard_const_p(char, "dwLastXfrAttempt"),
   18796             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_dwLastXfrAttempt,
   18797             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_dwLastXfrAttempt,
   18798             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   18799             :         },
   18800             :         {
   18801             :                 .name = discard_const_p(char, "dwLastXfrResult"),
   18802             :                 .get = py_DNS_RPC_ZONE_INFO_LONGHORN_get_dwLastXfrResult,
   18803             :                 .set = py_DNS_RPC_ZONE_INFO_LONGHORN_set_dwLastXfrResult,
   18804             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   18805             :         },
   18806             :         { .name = NULL }
   18807             : };
   18808             : 
   18809           0 : static PyObject *py_DNS_RPC_ZONE_INFO_LONGHORN_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   18810             : {
   18811           0 :         return pytalloc_new(struct DNS_RPC_ZONE_INFO_LONGHORN, type);
   18812             : }
   18813             : 
   18814             : 
   18815             : static PyTypeObject DNS_RPC_ZONE_INFO_LONGHORN_Type = {
   18816             :         PyVarObject_HEAD_INIT(NULL, 0)
   18817             :         .tp_name = "dnsserver.DNS_RPC_ZONE_INFO_LONGHORN",
   18818             :         .tp_getset = py_DNS_RPC_ZONE_INFO_LONGHORN_getsetters,
   18819             :         .tp_methods = NULL,
   18820             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   18821             :         .tp_new = py_DNS_RPC_ZONE_INFO_LONGHORN_new,
   18822             : };
   18823             : 
   18824             : 
   18825           0 : static PyObject *py_DNS_RPC_ZONE_SECONDARIES_W2K_get_fSecureSecondaries(PyObject *obj, void *closure)
   18826             : {
   18827           0 :         struct DNS_RPC_ZONE_SECONDARIES_W2K *object = pytalloc_get_ptr(obj);
   18828           0 :         PyObject *py_fSecureSecondaries;
   18829           0 :         py_fSecureSecondaries = PyLong_FromUnsignedLongLong((uint32_t)(object->fSecureSecondaries));
   18830           0 :         return py_fSecureSecondaries;
   18831             : }
   18832             : 
   18833           0 : static int py_DNS_RPC_ZONE_SECONDARIES_W2K_set_fSecureSecondaries(PyObject *py_obj, PyObject *value, void *closure)
   18834             : {
   18835           0 :         struct DNS_RPC_ZONE_SECONDARIES_W2K *object = pytalloc_get_ptr(py_obj);
   18836           0 :         if (value == NULL) {
   18837           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fSecureSecondaries");
   18838           0 :                 return -1;
   18839             :         }
   18840             :         {
   18841           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fSecureSecondaries));
   18842           0 :                 if (PyLong_Check(value)) {
   18843           0 :                         unsigned long long test_var;
   18844           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   18845           0 :                         if (PyErr_Occurred() != NULL) {
   18846           0 :                                 return -1;
   18847             :                         }
   18848           0 :                         if (test_var > uint_max) {
   18849           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   18850             :                                   PyLong_Type.tp_name, uint_max, test_var);
   18851           0 :                                 return -1;
   18852             :                         }
   18853           0 :                         object->fSecureSecondaries = test_var;
   18854             :                 } else {
   18855           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   18856             :                           PyLong_Type.tp_name);
   18857           0 :                         return -1;
   18858             :                 }
   18859             :         }
   18860           0 :         return 0;
   18861             : }
   18862             : 
   18863           0 : static PyObject *py_DNS_RPC_ZONE_SECONDARIES_W2K_get_fNotifyLevel(PyObject *obj, void *closure)
   18864             : {
   18865           0 :         struct DNS_RPC_ZONE_SECONDARIES_W2K *object = pytalloc_get_ptr(obj);
   18866           0 :         PyObject *py_fNotifyLevel;
   18867           0 :         py_fNotifyLevel = PyLong_FromUnsignedLongLong((uint32_t)(object->fNotifyLevel));
   18868           0 :         return py_fNotifyLevel;
   18869             : }
   18870             : 
   18871           0 : static int py_DNS_RPC_ZONE_SECONDARIES_W2K_set_fNotifyLevel(PyObject *py_obj, PyObject *value, void *closure)
   18872             : {
   18873           0 :         struct DNS_RPC_ZONE_SECONDARIES_W2K *object = pytalloc_get_ptr(py_obj);
   18874           0 :         if (value == NULL) {
   18875           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fNotifyLevel");
   18876           0 :                 return -1;
   18877             :         }
   18878             :         {
   18879           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fNotifyLevel));
   18880           0 :                 if (PyLong_Check(value)) {
   18881           0 :                         unsigned long long test_var;
   18882           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   18883           0 :                         if (PyErr_Occurred() != NULL) {
   18884           0 :                                 return -1;
   18885             :                         }
   18886           0 :                         if (test_var > uint_max) {
   18887           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   18888             :                                   PyLong_Type.tp_name, uint_max, test_var);
   18889           0 :                                 return -1;
   18890             :                         }
   18891           0 :                         object->fNotifyLevel = test_var;
   18892             :                 } else {
   18893           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   18894             :                           PyLong_Type.tp_name);
   18895           0 :                         return -1;
   18896             :                 }
   18897             :         }
   18898           0 :         return 0;
   18899             : }
   18900             : 
   18901           0 : static PyObject *py_DNS_RPC_ZONE_SECONDARIES_W2K_get_aipSecondaries(PyObject *obj, void *closure)
   18902             : {
   18903           0 :         struct DNS_RPC_ZONE_SECONDARIES_W2K *object = pytalloc_get_ptr(obj);
   18904           0 :         PyObject *py_aipSecondaries;
   18905           0 :         if (object->aipSecondaries == NULL) {
   18906           0 :                 Py_RETURN_NONE;
   18907             :         }
   18908           0 :         if (object->aipSecondaries == NULL) {
   18909           0 :                 py_aipSecondaries = Py_None;
   18910           0 :                 Py_INCREF(py_aipSecondaries);
   18911             :         } else {
   18912           0 :                 py_aipSecondaries = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipSecondaries, object->aipSecondaries);
   18913             :         }
   18914           0 :         return py_aipSecondaries;
   18915             : }
   18916             : 
   18917           0 : static int py_DNS_RPC_ZONE_SECONDARIES_W2K_set_aipSecondaries(PyObject *py_obj, PyObject *value, void *closure)
   18918             : {
   18919           0 :         struct DNS_RPC_ZONE_SECONDARIES_W2K *object = pytalloc_get_ptr(py_obj);
   18920           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipSecondaries));
   18921           0 :         if (value == NULL) {
   18922           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipSecondaries");
   18923           0 :                 return -1;
   18924             :         }
   18925           0 :         if (value == Py_None) {
   18926           0 :                 object->aipSecondaries = NULL;
   18927             :         } else {
   18928           0 :                 object->aipSecondaries = NULL;
   18929           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
   18930           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   18931           0 :                         PyErr_NoMemory();
   18932           0 :                         return -1;
   18933             :                 }
   18934           0 :                 object->aipSecondaries = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
   18935             :         }
   18936           0 :         return 0;
   18937             : }
   18938             : 
   18939           0 : static PyObject *py_DNS_RPC_ZONE_SECONDARIES_W2K_get_aipNotify(PyObject *obj, void *closure)
   18940             : {
   18941           0 :         struct DNS_RPC_ZONE_SECONDARIES_W2K *object = pytalloc_get_ptr(obj);
   18942           0 :         PyObject *py_aipNotify;
   18943           0 :         if (object->aipNotify == NULL) {
   18944           0 :                 Py_RETURN_NONE;
   18945             :         }
   18946           0 :         if (object->aipNotify == NULL) {
   18947           0 :                 py_aipNotify = Py_None;
   18948           0 :                 Py_INCREF(py_aipNotify);
   18949             :         } else {
   18950           0 :                 py_aipNotify = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipNotify, object->aipNotify);
   18951             :         }
   18952           0 :         return py_aipNotify;
   18953             : }
   18954             : 
   18955           0 : static int py_DNS_RPC_ZONE_SECONDARIES_W2K_set_aipNotify(PyObject *py_obj, PyObject *value, void *closure)
   18956             : {
   18957           0 :         struct DNS_RPC_ZONE_SECONDARIES_W2K *object = pytalloc_get_ptr(py_obj);
   18958           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipNotify));
   18959           0 :         if (value == NULL) {
   18960           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipNotify");
   18961           0 :                 return -1;
   18962             :         }
   18963           0 :         if (value == Py_None) {
   18964           0 :                 object->aipNotify = NULL;
   18965             :         } else {
   18966           0 :                 object->aipNotify = NULL;
   18967           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
   18968           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   18969           0 :                         PyErr_NoMemory();
   18970           0 :                         return -1;
   18971             :                 }
   18972           0 :                 object->aipNotify = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
   18973             :         }
   18974           0 :         return 0;
   18975             : }
   18976             : 
   18977             : static PyGetSetDef py_DNS_RPC_ZONE_SECONDARIES_W2K_getsetters[] = {
   18978             :         {
   18979             :                 .name = discard_const_p(char, "fSecureSecondaries"),
   18980             :                 .get = py_DNS_RPC_ZONE_SECONDARIES_W2K_get_fSecureSecondaries,
   18981             :                 .set = py_DNS_RPC_ZONE_SECONDARIES_W2K_set_fSecureSecondaries,
   18982             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ZONE_SECONDARY_SECURITY")
   18983             :         },
   18984             :         {
   18985             :                 .name = discard_const_p(char, "fNotifyLevel"),
   18986             :                 .get = py_DNS_RPC_ZONE_SECONDARIES_W2K_get_fNotifyLevel,
   18987             :                 .set = py_DNS_RPC_ZONE_SECONDARIES_W2K_set_fNotifyLevel,
   18988             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ZONE_NOTIFY_LEVEL")
   18989             :         },
   18990             :         {
   18991             :                 .name = discard_const_p(char, "aipSecondaries"),
   18992             :                 .get = py_DNS_RPC_ZONE_SECONDARIES_W2K_get_aipSecondaries,
   18993             :                 .set = py_DNS_RPC_ZONE_SECONDARIES_W2K_set_aipSecondaries,
   18994             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
   18995             :         },
   18996             :         {
   18997             :                 .name = discard_const_p(char, "aipNotify"),
   18998             :                 .get = py_DNS_RPC_ZONE_SECONDARIES_W2K_get_aipNotify,
   18999             :                 .set = py_DNS_RPC_ZONE_SECONDARIES_W2K_set_aipNotify,
   19000             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
   19001             :         },
   19002             :         { .name = NULL }
   19003             : };
   19004             : 
   19005           0 : static PyObject *py_DNS_RPC_ZONE_SECONDARIES_W2K_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   19006             : {
   19007           0 :         return pytalloc_new(struct DNS_RPC_ZONE_SECONDARIES_W2K, type);
   19008             : }
   19009             : 
   19010             : 
   19011             : static PyTypeObject DNS_RPC_ZONE_SECONDARIES_W2K_Type = {
   19012             :         PyVarObject_HEAD_INIT(NULL, 0)
   19013             :         .tp_name = "dnsserver.DNS_RPC_ZONE_SECONDARIES_W2K",
   19014             :         .tp_getset = py_DNS_RPC_ZONE_SECONDARIES_W2K_getsetters,
   19015             :         .tp_methods = NULL,
   19016             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   19017             :         .tp_new = py_DNS_RPC_ZONE_SECONDARIES_W2K_new,
   19018             : };
   19019             : 
   19020             : 
   19021           0 : static PyObject *py_DNS_RPC_ZONE_SECONDARIES_DOTNET_get_dwRpcStructureVersion(PyObject *obj, void *closure)
   19022             : {
   19023           0 :         struct DNS_RPC_ZONE_SECONDARIES_DOTNET *object = pytalloc_get_ptr(obj);
   19024           0 :         PyObject *py_dwRpcStructureVersion;
   19025           0 :         py_dwRpcStructureVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcStructureVersion));
   19026           0 :         return py_dwRpcStructureVersion;
   19027             : }
   19028             : 
   19029           0 : static int py_DNS_RPC_ZONE_SECONDARIES_DOTNET_set_dwRpcStructureVersion(PyObject *py_obj, PyObject *value, void *closure)
   19030             : {
   19031           0 :         struct DNS_RPC_ZONE_SECONDARIES_DOTNET *object = pytalloc_get_ptr(py_obj);
   19032           0 :         if (value == NULL) {
   19033           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcStructureVersion");
   19034           0 :                 return -1;
   19035             :         }
   19036             :         {
   19037           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcStructureVersion));
   19038           0 :                 if (PyLong_Check(value)) {
   19039           0 :                         unsigned long long test_var;
   19040           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   19041           0 :                         if (PyErr_Occurred() != NULL) {
   19042           0 :                                 return -1;
   19043             :                         }
   19044           0 :                         if (test_var > uint_max) {
   19045           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   19046             :                                   PyLong_Type.tp_name, uint_max, test_var);
   19047           0 :                                 return -1;
   19048             :                         }
   19049           0 :                         object->dwRpcStructureVersion = test_var;
   19050             :                 } else {
   19051           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   19052             :                           PyLong_Type.tp_name);
   19053           0 :                         return -1;
   19054             :                 }
   19055             :         }
   19056           0 :         return 0;
   19057             : }
   19058             : 
   19059           0 : static PyObject *py_DNS_RPC_ZONE_SECONDARIES_DOTNET_get_dwReserved0(PyObject *obj, void *closure)
   19060             : {
   19061           0 :         struct DNS_RPC_ZONE_SECONDARIES_DOTNET *object = pytalloc_get_ptr(obj);
   19062           0 :         PyObject *py_dwReserved0;
   19063           0 :         py_dwReserved0 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved0));
   19064           0 :         return py_dwReserved0;
   19065             : }
   19066             : 
   19067           0 : static int py_DNS_RPC_ZONE_SECONDARIES_DOTNET_set_dwReserved0(PyObject *py_obj, PyObject *value, void *closure)
   19068             : {
   19069           0 :         struct DNS_RPC_ZONE_SECONDARIES_DOTNET *object = pytalloc_get_ptr(py_obj);
   19070           0 :         if (value == NULL) {
   19071           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved0");
   19072           0 :                 return -1;
   19073             :         }
   19074             :         {
   19075           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved0));
   19076           0 :                 if (PyLong_Check(value)) {
   19077           0 :                         unsigned long long test_var;
   19078           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   19079           0 :                         if (PyErr_Occurred() != NULL) {
   19080           0 :                                 return -1;
   19081             :                         }
   19082           0 :                         if (test_var > uint_max) {
   19083           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   19084             :                                   PyLong_Type.tp_name, uint_max, test_var);
   19085           0 :                                 return -1;
   19086             :                         }
   19087           0 :                         object->dwReserved0 = test_var;
   19088             :                 } else {
   19089           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   19090             :                           PyLong_Type.tp_name);
   19091           0 :                         return -1;
   19092             :                 }
   19093             :         }
   19094           0 :         return 0;
   19095             : }
   19096             : 
   19097           0 : static PyObject *py_DNS_RPC_ZONE_SECONDARIES_DOTNET_get_fSecureSecondaries(PyObject *obj, void *closure)
   19098             : {
   19099           0 :         struct DNS_RPC_ZONE_SECONDARIES_DOTNET *object = pytalloc_get_ptr(obj);
   19100           0 :         PyObject *py_fSecureSecondaries;
   19101           0 :         py_fSecureSecondaries = PyLong_FromUnsignedLongLong((uint32_t)(object->fSecureSecondaries));
   19102           0 :         return py_fSecureSecondaries;
   19103             : }
   19104             : 
   19105           0 : static int py_DNS_RPC_ZONE_SECONDARIES_DOTNET_set_fSecureSecondaries(PyObject *py_obj, PyObject *value, void *closure)
   19106             : {
   19107           0 :         struct DNS_RPC_ZONE_SECONDARIES_DOTNET *object = pytalloc_get_ptr(py_obj);
   19108           0 :         if (value == NULL) {
   19109           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fSecureSecondaries");
   19110           0 :                 return -1;
   19111             :         }
   19112             :         {
   19113           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fSecureSecondaries));
   19114           0 :                 if (PyLong_Check(value)) {
   19115           0 :                         unsigned long long test_var;
   19116           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   19117           0 :                         if (PyErr_Occurred() != NULL) {
   19118           0 :                                 return -1;
   19119             :                         }
   19120           0 :                         if (test_var > uint_max) {
   19121           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   19122             :                                   PyLong_Type.tp_name, uint_max, test_var);
   19123           0 :                                 return -1;
   19124             :                         }
   19125           0 :                         object->fSecureSecondaries = test_var;
   19126             :                 } else {
   19127           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   19128             :                           PyLong_Type.tp_name);
   19129           0 :                         return -1;
   19130             :                 }
   19131             :         }
   19132           0 :         return 0;
   19133             : }
   19134             : 
   19135           0 : static PyObject *py_DNS_RPC_ZONE_SECONDARIES_DOTNET_get_fNotifyLevel(PyObject *obj, void *closure)
   19136             : {
   19137           0 :         struct DNS_RPC_ZONE_SECONDARIES_DOTNET *object = pytalloc_get_ptr(obj);
   19138           0 :         PyObject *py_fNotifyLevel;
   19139           0 :         py_fNotifyLevel = PyLong_FromUnsignedLongLong((uint32_t)(object->fNotifyLevel));
   19140           0 :         return py_fNotifyLevel;
   19141             : }
   19142             : 
   19143           0 : static int py_DNS_RPC_ZONE_SECONDARIES_DOTNET_set_fNotifyLevel(PyObject *py_obj, PyObject *value, void *closure)
   19144             : {
   19145           0 :         struct DNS_RPC_ZONE_SECONDARIES_DOTNET *object = pytalloc_get_ptr(py_obj);
   19146           0 :         if (value == NULL) {
   19147           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fNotifyLevel");
   19148           0 :                 return -1;
   19149             :         }
   19150             :         {
   19151           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fNotifyLevel));
   19152           0 :                 if (PyLong_Check(value)) {
   19153           0 :                         unsigned long long test_var;
   19154           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   19155           0 :                         if (PyErr_Occurred() != NULL) {
   19156           0 :                                 return -1;
   19157             :                         }
   19158           0 :                         if (test_var > uint_max) {
   19159           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   19160             :                                   PyLong_Type.tp_name, uint_max, test_var);
   19161           0 :                                 return -1;
   19162             :                         }
   19163           0 :                         object->fNotifyLevel = test_var;
   19164             :                 } else {
   19165           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   19166             :                           PyLong_Type.tp_name);
   19167           0 :                         return -1;
   19168             :                 }
   19169             :         }
   19170           0 :         return 0;
   19171             : }
   19172             : 
   19173           0 : static PyObject *py_DNS_RPC_ZONE_SECONDARIES_DOTNET_get_aipSecondaries(PyObject *obj, void *closure)
   19174             : {
   19175           0 :         struct DNS_RPC_ZONE_SECONDARIES_DOTNET *object = pytalloc_get_ptr(obj);
   19176           0 :         PyObject *py_aipSecondaries;
   19177           0 :         if (object->aipSecondaries == NULL) {
   19178           0 :                 Py_RETURN_NONE;
   19179             :         }
   19180           0 :         if (object->aipSecondaries == NULL) {
   19181           0 :                 py_aipSecondaries = Py_None;
   19182           0 :                 Py_INCREF(py_aipSecondaries);
   19183             :         } else {
   19184           0 :                 py_aipSecondaries = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipSecondaries, object->aipSecondaries);
   19185             :         }
   19186           0 :         return py_aipSecondaries;
   19187             : }
   19188             : 
   19189           0 : static int py_DNS_RPC_ZONE_SECONDARIES_DOTNET_set_aipSecondaries(PyObject *py_obj, PyObject *value, void *closure)
   19190             : {
   19191           0 :         struct DNS_RPC_ZONE_SECONDARIES_DOTNET *object = pytalloc_get_ptr(py_obj);
   19192           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipSecondaries));
   19193           0 :         if (value == NULL) {
   19194           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipSecondaries");
   19195           0 :                 return -1;
   19196             :         }
   19197           0 :         if (value == Py_None) {
   19198           0 :                 object->aipSecondaries = NULL;
   19199             :         } else {
   19200           0 :                 object->aipSecondaries = NULL;
   19201           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
   19202           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   19203           0 :                         PyErr_NoMemory();
   19204           0 :                         return -1;
   19205             :                 }
   19206           0 :                 object->aipSecondaries = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
   19207             :         }
   19208           0 :         return 0;
   19209             : }
   19210             : 
   19211           0 : static PyObject *py_DNS_RPC_ZONE_SECONDARIES_DOTNET_get_aipNotify(PyObject *obj, void *closure)
   19212             : {
   19213           0 :         struct DNS_RPC_ZONE_SECONDARIES_DOTNET *object = pytalloc_get_ptr(obj);
   19214           0 :         PyObject *py_aipNotify;
   19215           0 :         if (object->aipNotify == NULL) {
   19216           0 :                 Py_RETURN_NONE;
   19217             :         }
   19218           0 :         if (object->aipNotify == NULL) {
   19219           0 :                 py_aipNotify = Py_None;
   19220           0 :                 Py_INCREF(py_aipNotify);
   19221             :         } else {
   19222           0 :                 py_aipNotify = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipNotify, object->aipNotify);
   19223             :         }
   19224           0 :         return py_aipNotify;
   19225             : }
   19226             : 
   19227           0 : static int py_DNS_RPC_ZONE_SECONDARIES_DOTNET_set_aipNotify(PyObject *py_obj, PyObject *value, void *closure)
   19228             : {
   19229           0 :         struct DNS_RPC_ZONE_SECONDARIES_DOTNET *object = pytalloc_get_ptr(py_obj);
   19230           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipNotify));
   19231           0 :         if (value == NULL) {
   19232           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipNotify");
   19233           0 :                 return -1;
   19234             :         }
   19235           0 :         if (value == Py_None) {
   19236           0 :                 object->aipNotify = NULL;
   19237             :         } else {
   19238           0 :                 object->aipNotify = NULL;
   19239           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
   19240           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   19241           0 :                         PyErr_NoMemory();
   19242           0 :                         return -1;
   19243             :                 }
   19244           0 :                 object->aipNotify = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
   19245             :         }
   19246           0 :         return 0;
   19247             : }
   19248             : 
   19249             : static PyGetSetDef py_DNS_RPC_ZONE_SECONDARIES_DOTNET_getsetters[] = {
   19250             :         {
   19251             :                 .name = discard_const_p(char, "dwRpcStructureVersion"),
   19252             :                 .get = py_DNS_RPC_ZONE_SECONDARIES_DOTNET_get_dwRpcStructureVersion,
   19253             :                 .set = py_DNS_RPC_ZONE_SECONDARIES_DOTNET_set_dwRpcStructureVersion,
   19254             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   19255             :         },
   19256             :         {
   19257             :                 .name = discard_const_p(char, "dwReserved0"),
   19258             :                 .get = py_DNS_RPC_ZONE_SECONDARIES_DOTNET_get_dwReserved0,
   19259             :                 .set = py_DNS_RPC_ZONE_SECONDARIES_DOTNET_set_dwReserved0,
   19260             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   19261             :         },
   19262             :         {
   19263             :                 .name = discard_const_p(char, "fSecureSecondaries"),
   19264             :                 .get = py_DNS_RPC_ZONE_SECONDARIES_DOTNET_get_fSecureSecondaries,
   19265             :                 .set = py_DNS_RPC_ZONE_SECONDARIES_DOTNET_set_fSecureSecondaries,
   19266             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ZONE_SECONDARY_SECURITY")
   19267             :         },
   19268             :         {
   19269             :                 .name = discard_const_p(char, "fNotifyLevel"),
   19270             :                 .get = py_DNS_RPC_ZONE_SECONDARIES_DOTNET_get_fNotifyLevel,
   19271             :                 .set = py_DNS_RPC_ZONE_SECONDARIES_DOTNET_set_fNotifyLevel,
   19272             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ZONE_NOTIFY_LEVEL")
   19273             :         },
   19274             :         {
   19275             :                 .name = discard_const_p(char, "aipSecondaries"),
   19276             :                 .get = py_DNS_RPC_ZONE_SECONDARIES_DOTNET_get_aipSecondaries,
   19277             :                 .set = py_DNS_RPC_ZONE_SECONDARIES_DOTNET_set_aipSecondaries,
   19278             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
   19279             :         },
   19280             :         {
   19281             :                 .name = discard_const_p(char, "aipNotify"),
   19282             :                 .get = py_DNS_RPC_ZONE_SECONDARIES_DOTNET_get_aipNotify,
   19283             :                 .set = py_DNS_RPC_ZONE_SECONDARIES_DOTNET_set_aipNotify,
   19284             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
   19285             :         },
   19286             :         { .name = NULL }
   19287             : };
   19288             : 
   19289           0 : static PyObject *py_DNS_RPC_ZONE_SECONDARIES_DOTNET_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   19290             : {
   19291           0 :         return pytalloc_new(struct DNS_RPC_ZONE_SECONDARIES_DOTNET, type);
   19292             : }
   19293             : 
   19294             : 
   19295             : static PyTypeObject DNS_RPC_ZONE_SECONDARIES_DOTNET_Type = {
   19296             :         PyVarObject_HEAD_INIT(NULL, 0)
   19297             :         .tp_name = "dnsserver.DNS_RPC_ZONE_SECONDARIES_DOTNET",
   19298             :         .tp_getset = py_DNS_RPC_ZONE_SECONDARIES_DOTNET_getsetters,
   19299             :         .tp_methods = NULL,
   19300             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   19301             :         .tp_new = py_DNS_RPC_ZONE_SECONDARIES_DOTNET_new,
   19302             : };
   19303             : 
   19304             : 
   19305           0 : static PyObject *py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_get_dwRpcStructureVersion(PyObject *obj, void *closure)
   19306             : {
   19307           0 :         struct DNS_RPC_ZONE_SECONDARIES_LONGHORN *object = pytalloc_get_ptr(obj);
   19308           0 :         PyObject *py_dwRpcStructureVersion;
   19309           0 :         py_dwRpcStructureVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcStructureVersion));
   19310           0 :         return py_dwRpcStructureVersion;
   19311             : }
   19312             : 
   19313           0 : static int py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_set_dwRpcStructureVersion(PyObject *py_obj, PyObject *value, void *closure)
   19314             : {
   19315           0 :         struct DNS_RPC_ZONE_SECONDARIES_LONGHORN *object = pytalloc_get_ptr(py_obj);
   19316           0 :         if (value == NULL) {
   19317           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcStructureVersion");
   19318           0 :                 return -1;
   19319             :         }
   19320             :         {
   19321           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcStructureVersion));
   19322           0 :                 if (PyLong_Check(value)) {
   19323           0 :                         unsigned long long test_var;
   19324           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   19325           0 :                         if (PyErr_Occurred() != NULL) {
   19326           0 :                                 return -1;
   19327             :                         }
   19328           0 :                         if (test_var > uint_max) {
   19329           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   19330             :                                   PyLong_Type.tp_name, uint_max, test_var);
   19331           0 :                                 return -1;
   19332             :                         }
   19333           0 :                         object->dwRpcStructureVersion = test_var;
   19334             :                 } else {
   19335           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   19336             :                           PyLong_Type.tp_name);
   19337           0 :                         return -1;
   19338             :                 }
   19339             :         }
   19340           0 :         return 0;
   19341             : }
   19342             : 
   19343           0 : static PyObject *py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_get_dwReserved0(PyObject *obj, void *closure)
   19344             : {
   19345           0 :         struct DNS_RPC_ZONE_SECONDARIES_LONGHORN *object = pytalloc_get_ptr(obj);
   19346           0 :         PyObject *py_dwReserved0;
   19347           0 :         py_dwReserved0 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved0));
   19348           0 :         return py_dwReserved0;
   19349             : }
   19350             : 
   19351           0 : static int py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_set_dwReserved0(PyObject *py_obj, PyObject *value, void *closure)
   19352             : {
   19353           0 :         struct DNS_RPC_ZONE_SECONDARIES_LONGHORN *object = pytalloc_get_ptr(py_obj);
   19354           0 :         if (value == NULL) {
   19355           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved0");
   19356           0 :                 return -1;
   19357             :         }
   19358             :         {
   19359           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved0));
   19360           0 :                 if (PyLong_Check(value)) {
   19361           0 :                         unsigned long long test_var;
   19362           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   19363           0 :                         if (PyErr_Occurred() != NULL) {
   19364           0 :                                 return -1;
   19365             :                         }
   19366           0 :                         if (test_var > uint_max) {
   19367           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   19368             :                                   PyLong_Type.tp_name, uint_max, test_var);
   19369           0 :                                 return -1;
   19370             :                         }
   19371           0 :                         object->dwReserved0 = test_var;
   19372             :                 } else {
   19373           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   19374             :                           PyLong_Type.tp_name);
   19375           0 :                         return -1;
   19376             :                 }
   19377             :         }
   19378           0 :         return 0;
   19379             : }
   19380             : 
   19381           0 : static PyObject *py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_get_fSecureSecondaries(PyObject *obj, void *closure)
   19382             : {
   19383           0 :         struct DNS_RPC_ZONE_SECONDARIES_LONGHORN *object = pytalloc_get_ptr(obj);
   19384           0 :         PyObject *py_fSecureSecondaries;
   19385           0 :         py_fSecureSecondaries = PyLong_FromUnsignedLongLong((uint32_t)(object->fSecureSecondaries));
   19386           0 :         return py_fSecureSecondaries;
   19387             : }
   19388             : 
   19389           0 : static int py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_set_fSecureSecondaries(PyObject *py_obj, PyObject *value, void *closure)
   19390             : {
   19391           0 :         struct DNS_RPC_ZONE_SECONDARIES_LONGHORN *object = pytalloc_get_ptr(py_obj);
   19392           0 :         if (value == NULL) {
   19393           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fSecureSecondaries");
   19394           0 :                 return -1;
   19395             :         }
   19396             :         {
   19397           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fSecureSecondaries));
   19398           0 :                 if (PyLong_Check(value)) {
   19399           0 :                         unsigned long long test_var;
   19400           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   19401           0 :                         if (PyErr_Occurred() != NULL) {
   19402           0 :                                 return -1;
   19403             :                         }
   19404           0 :                         if (test_var > uint_max) {
   19405           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   19406             :                                   PyLong_Type.tp_name, uint_max, test_var);
   19407           0 :                                 return -1;
   19408             :                         }
   19409           0 :                         object->fSecureSecondaries = test_var;
   19410             :                 } else {
   19411           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   19412             :                           PyLong_Type.tp_name);
   19413           0 :                         return -1;
   19414             :                 }
   19415             :         }
   19416           0 :         return 0;
   19417             : }
   19418             : 
   19419           0 : static PyObject *py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_get_fNotifyLevel(PyObject *obj, void *closure)
   19420             : {
   19421           0 :         struct DNS_RPC_ZONE_SECONDARIES_LONGHORN *object = pytalloc_get_ptr(obj);
   19422           0 :         PyObject *py_fNotifyLevel;
   19423           0 :         py_fNotifyLevel = PyLong_FromUnsignedLongLong((uint32_t)(object->fNotifyLevel));
   19424           0 :         return py_fNotifyLevel;
   19425             : }
   19426             : 
   19427           0 : static int py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_set_fNotifyLevel(PyObject *py_obj, PyObject *value, void *closure)
   19428             : {
   19429           0 :         struct DNS_RPC_ZONE_SECONDARIES_LONGHORN *object = pytalloc_get_ptr(py_obj);
   19430           0 :         if (value == NULL) {
   19431           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fNotifyLevel");
   19432           0 :                 return -1;
   19433             :         }
   19434             :         {
   19435           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fNotifyLevel));
   19436           0 :                 if (PyLong_Check(value)) {
   19437           0 :                         unsigned long long test_var;
   19438           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   19439           0 :                         if (PyErr_Occurred() != NULL) {
   19440           0 :                                 return -1;
   19441             :                         }
   19442           0 :                         if (test_var > uint_max) {
   19443           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   19444             :                                   PyLong_Type.tp_name, uint_max, test_var);
   19445           0 :                                 return -1;
   19446             :                         }
   19447           0 :                         object->fNotifyLevel = test_var;
   19448             :                 } else {
   19449           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   19450             :                           PyLong_Type.tp_name);
   19451           0 :                         return -1;
   19452             :                 }
   19453             :         }
   19454           0 :         return 0;
   19455             : }
   19456             : 
   19457           0 : static PyObject *py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_get_aipSecondaries(PyObject *obj, void *closure)
   19458             : {
   19459           0 :         struct DNS_RPC_ZONE_SECONDARIES_LONGHORN *object = pytalloc_get_ptr(obj);
   19460           0 :         PyObject *py_aipSecondaries;
   19461           0 :         if (object->aipSecondaries == NULL) {
   19462           0 :                 Py_RETURN_NONE;
   19463             :         }
   19464           0 :         if (object->aipSecondaries == NULL) {
   19465           0 :                 py_aipSecondaries = Py_None;
   19466           0 :                 Py_INCREF(py_aipSecondaries);
   19467             :         } else {
   19468           0 :                 py_aipSecondaries = pytalloc_reference_ex(&DNS_ADDR_ARRAY_Type, object->aipSecondaries, object->aipSecondaries);
   19469             :         }
   19470           0 :         return py_aipSecondaries;
   19471             : }
   19472             : 
   19473           0 : static int py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_set_aipSecondaries(PyObject *py_obj, PyObject *value, void *closure)
   19474             : {
   19475           0 :         struct DNS_RPC_ZONE_SECONDARIES_LONGHORN *object = pytalloc_get_ptr(py_obj);
   19476           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipSecondaries));
   19477           0 :         if (value == NULL) {
   19478           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipSecondaries");
   19479           0 :                 return -1;
   19480             :         }
   19481           0 :         if (value == Py_None) {
   19482           0 :                 object->aipSecondaries = NULL;
   19483             :         } else {
   19484           0 :                 object->aipSecondaries = NULL;
   19485           0 :                 PY_CHECK_TYPE(&DNS_ADDR_ARRAY_Type, value, return -1;);
   19486           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   19487           0 :                         PyErr_NoMemory();
   19488           0 :                         return -1;
   19489             :                 }
   19490           0 :                 object->aipSecondaries = (struct DNS_ADDR_ARRAY *)pytalloc_get_ptr(value);
   19491             :         }
   19492           0 :         return 0;
   19493             : }
   19494             : 
   19495           0 : static PyObject *py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_get_aipNotify(PyObject *obj, void *closure)
   19496             : {
   19497           0 :         struct DNS_RPC_ZONE_SECONDARIES_LONGHORN *object = pytalloc_get_ptr(obj);
   19498           0 :         PyObject *py_aipNotify;
   19499           0 :         if (object->aipNotify == NULL) {
   19500           0 :                 Py_RETURN_NONE;
   19501             :         }
   19502           0 :         if (object->aipNotify == NULL) {
   19503           0 :                 py_aipNotify = Py_None;
   19504           0 :                 Py_INCREF(py_aipNotify);
   19505             :         } else {
   19506           0 :                 py_aipNotify = pytalloc_reference_ex(&DNS_ADDR_ARRAY_Type, object->aipNotify, object->aipNotify);
   19507             :         }
   19508           0 :         return py_aipNotify;
   19509             : }
   19510             : 
   19511           0 : static int py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_set_aipNotify(PyObject *py_obj, PyObject *value, void *closure)
   19512             : {
   19513           0 :         struct DNS_RPC_ZONE_SECONDARIES_LONGHORN *object = pytalloc_get_ptr(py_obj);
   19514           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipNotify));
   19515           0 :         if (value == NULL) {
   19516           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipNotify");
   19517           0 :                 return -1;
   19518             :         }
   19519           0 :         if (value == Py_None) {
   19520           0 :                 object->aipNotify = NULL;
   19521             :         } else {
   19522           0 :                 object->aipNotify = NULL;
   19523           0 :                 PY_CHECK_TYPE(&DNS_ADDR_ARRAY_Type, value, return -1;);
   19524           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   19525           0 :                         PyErr_NoMemory();
   19526           0 :                         return -1;
   19527             :                 }
   19528           0 :                 object->aipNotify = (struct DNS_ADDR_ARRAY *)pytalloc_get_ptr(value);
   19529             :         }
   19530           0 :         return 0;
   19531             : }
   19532             : 
   19533             : static PyGetSetDef py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_getsetters[] = {
   19534             :         {
   19535             :                 .name = discard_const_p(char, "dwRpcStructureVersion"),
   19536             :                 .get = py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_get_dwRpcStructureVersion,
   19537             :                 .set = py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_set_dwRpcStructureVersion,
   19538             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   19539             :         },
   19540             :         {
   19541             :                 .name = discard_const_p(char, "dwReserved0"),
   19542             :                 .get = py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_get_dwReserved0,
   19543             :                 .set = py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_set_dwReserved0,
   19544             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   19545             :         },
   19546             :         {
   19547             :                 .name = discard_const_p(char, "fSecureSecondaries"),
   19548             :                 .get = py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_get_fSecureSecondaries,
   19549             :                 .set = py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_set_fSecureSecondaries,
   19550             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ZONE_SECONDARY_SECURITY")
   19551             :         },
   19552             :         {
   19553             :                 .name = discard_const_p(char, "fNotifyLevel"),
   19554             :                 .get = py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_get_fNotifyLevel,
   19555             :                 .set = py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_set_fNotifyLevel,
   19556             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ZONE_NOTIFY_LEVEL")
   19557             :         },
   19558             :         {
   19559             :                 .name = discard_const_p(char, "aipSecondaries"),
   19560             :                 .get = py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_get_aipSecondaries,
   19561             :                 .set = py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_set_aipSecondaries,
   19562             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ADDR_ARRAY")
   19563             :         },
   19564             :         {
   19565             :                 .name = discard_const_p(char, "aipNotify"),
   19566             :                 .get = py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_get_aipNotify,
   19567             :                 .set = py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_set_aipNotify,
   19568             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ADDR_ARRAY")
   19569             :         },
   19570             :         { .name = NULL }
   19571             : };
   19572             : 
   19573           0 : static PyObject *py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   19574             : {
   19575           0 :         return pytalloc_new(struct DNS_RPC_ZONE_SECONDARIES_LONGHORN, type);
   19576             : }
   19577             : 
   19578             : 
   19579             : static PyTypeObject DNS_RPC_ZONE_SECONDARIES_LONGHORN_Type = {
   19580             :         PyVarObject_HEAD_INIT(NULL, 0)
   19581             :         .tp_name = "dnsserver.DNS_RPC_ZONE_SECONDARIES_LONGHORN",
   19582             :         .tp_getset = py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_getsetters,
   19583             :         .tp_methods = NULL,
   19584             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   19585             :         .tp_new = py_DNS_RPC_ZONE_SECONDARIES_LONGHORN_new,
   19586             : };
   19587             : 
   19588             : 
   19589           0 : static PyObject *py_DNS_RPC_ZONE_DATABASE_W2K_get_fDsIntegrated(PyObject *obj, void *closure)
   19590             : {
   19591           0 :         struct DNS_RPC_ZONE_DATABASE_W2K *object = pytalloc_get_ptr(obj);
   19592           0 :         PyObject *py_fDsIntegrated;
   19593           0 :         py_fDsIntegrated = PyLong_FromUnsignedLongLong((uint32_t)(object->fDsIntegrated));
   19594           0 :         return py_fDsIntegrated;
   19595             : }
   19596             : 
   19597           0 : static int py_DNS_RPC_ZONE_DATABASE_W2K_set_fDsIntegrated(PyObject *py_obj, PyObject *value, void *closure)
   19598             : {
   19599           0 :         struct DNS_RPC_ZONE_DATABASE_W2K *object = pytalloc_get_ptr(py_obj);
   19600           0 :         if (value == NULL) {
   19601           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fDsIntegrated");
   19602           0 :                 return -1;
   19603             :         }
   19604             :         {
   19605           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fDsIntegrated));
   19606           0 :                 if (PyLong_Check(value)) {
   19607           0 :                         unsigned long long test_var;
   19608           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   19609           0 :                         if (PyErr_Occurred() != NULL) {
   19610           0 :                                 return -1;
   19611             :                         }
   19612           0 :                         if (test_var > uint_max) {
   19613           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   19614             :                                   PyLong_Type.tp_name, uint_max, test_var);
   19615           0 :                                 return -1;
   19616             :                         }
   19617           0 :                         object->fDsIntegrated = test_var;
   19618             :                 } else {
   19619           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   19620             :                           PyLong_Type.tp_name);
   19621           0 :                         return -1;
   19622             :                 }
   19623             :         }
   19624           0 :         return 0;
   19625             : }
   19626             : 
   19627           0 : static PyObject *py_DNS_RPC_ZONE_DATABASE_W2K_get_pszFileName(PyObject *obj, void *closure)
   19628             : {
   19629           0 :         struct DNS_RPC_ZONE_DATABASE_W2K *object = pytalloc_get_ptr(obj);
   19630           0 :         PyObject *py_pszFileName;
   19631           0 :         if (object->pszFileName == NULL) {
   19632           0 :                 Py_RETURN_NONE;
   19633             :         }
   19634           0 :         if (object->pszFileName == NULL) {
   19635           0 :                 py_pszFileName = Py_None;
   19636           0 :                 Py_INCREF(py_pszFileName);
   19637             :         } else {
   19638           0 :                 if (object->pszFileName == NULL) {
   19639           0 :                         py_pszFileName = Py_None;
   19640           0 :                         Py_INCREF(py_pszFileName);
   19641             :                 } else {
   19642           0 :                         py_pszFileName = PyUnicode_Decode(object->pszFileName, strlen(object->pszFileName), "utf-8", "ignore");
   19643             :                 }
   19644             :         }
   19645           0 :         return py_pszFileName;
   19646             : }
   19647             : 
   19648           0 : static int py_DNS_RPC_ZONE_DATABASE_W2K_set_pszFileName(PyObject *py_obj, PyObject *value, void *closure)
   19649             : {
   19650           0 :         struct DNS_RPC_ZONE_DATABASE_W2K *object = pytalloc_get_ptr(py_obj);
   19651           0 :         if (value == NULL) {
   19652           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszFileName");
   19653           0 :                 return -1;
   19654             :         }
   19655           0 :         if (value == Py_None) {
   19656           0 :                 object->pszFileName = NULL;
   19657             :         } else {
   19658           0 :                 object->pszFileName = NULL;
   19659             :                 {
   19660           0 :                         const char *test_str;
   19661           0 :                         const char *talloc_str;
   19662           0 :                         PyObject *unicode = NULL;
   19663           0 :                         if (PyUnicode_Check(value)) {
   19664           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   19665           0 :                                 if (unicode == NULL) {
   19666           0 :                                         return -1;
   19667             :                                 }
   19668           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   19669           0 :                         } else if (PyBytes_Check(value)) {
   19670           0 :                                 test_str = PyBytes_AS_STRING(value);
   19671             :                         } else {
   19672           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   19673           0 :                                 return -1;
   19674             :                         }
   19675           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   19676           0 :                         if (unicode != NULL) {
   19677           0 :                                 Py_DECREF(unicode);
   19678             :                         }
   19679           0 :                         if (talloc_str == NULL) {
   19680           0 :                                 PyErr_NoMemory();
   19681           0 :                                 return -1;
   19682             :                         }
   19683           0 :                         object->pszFileName = talloc_str;
   19684             :                 }
   19685             :         }
   19686           0 :         return 0;
   19687             : }
   19688             : 
   19689             : static PyGetSetDef py_DNS_RPC_ZONE_DATABASE_W2K_getsetters[] = {
   19690             :         {
   19691             :                 .name = discard_const_p(char, "fDsIntegrated"),
   19692             :                 .get = py_DNS_RPC_ZONE_DATABASE_W2K_get_fDsIntegrated,
   19693             :                 .set = py_DNS_RPC_ZONE_DATABASE_W2K_set_fDsIntegrated,
   19694             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   19695             :         },
   19696             :         {
   19697             :                 .name = discard_const_p(char, "pszFileName"),
   19698             :                 .get = py_DNS_RPC_ZONE_DATABASE_W2K_get_pszFileName,
   19699             :                 .set = py_DNS_RPC_ZONE_DATABASE_W2K_set_pszFileName,
   19700             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   19701             :         },
   19702             :         { .name = NULL }
   19703             : };
   19704             : 
   19705           0 : static PyObject *py_DNS_RPC_ZONE_DATABASE_W2K_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   19706             : {
   19707           0 :         return pytalloc_new(struct DNS_RPC_ZONE_DATABASE_W2K, type);
   19708             : }
   19709             : 
   19710             : 
   19711             : static PyTypeObject DNS_RPC_ZONE_DATABASE_W2K_Type = {
   19712             :         PyVarObject_HEAD_INIT(NULL, 0)
   19713             :         .tp_name = "dnsserver.DNS_RPC_ZONE_DATABASE_W2K",
   19714             :         .tp_getset = py_DNS_RPC_ZONE_DATABASE_W2K_getsetters,
   19715             :         .tp_methods = NULL,
   19716             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   19717             :         .tp_new = py_DNS_RPC_ZONE_DATABASE_W2K_new,
   19718             : };
   19719             : 
   19720             : 
   19721           0 : static PyObject *py_DNS_RPC_ZONE_DATABASE_DOTNET_get_dwRpcStructureVersion(PyObject *obj, void *closure)
   19722             : {
   19723           0 :         struct DNS_RPC_ZONE_DATABASE_DOTNET *object = pytalloc_get_ptr(obj);
   19724           0 :         PyObject *py_dwRpcStructureVersion;
   19725           0 :         py_dwRpcStructureVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcStructureVersion));
   19726           0 :         return py_dwRpcStructureVersion;
   19727             : }
   19728             : 
   19729           0 : static int py_DNS_RPC_ZONE_DATABASE_DOTNET_set_dwRpcStructureVersion(PyObject *py_obj, PyObject *value, void *closure)
   19730             : {
   19731           0 :         struct DNS_RPC_ZONE_DATABASE_DOTNET *object = pytalloc_get_ptr(py_obj);
   19732           0 :         if (value == NULL) {
   19733           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcStructureVersion");
   19734           0 :                 return -1;
   19735             :         }
   19736             :         {
   19737           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcStructureVersion));
   19738           0 :                 if (PyLong_Check(value)) {
   19739           0 :                         unsigned long long test_var;
   19740           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   19741           0 :                         if (PyErr_Occurred() != NULL) {
   19742           0 :                                 return -1;
   19743             :                         }
   19744           0 :                         if (test_var > uint_max) {
   19745           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   19746             :                                   PyLong_Type.tp_name, uint_max, test_var);
   19747           0 :                                 return -1;
   19748             :                         }
   19749           0 :                         object->dwRpcStructureVersion = test_var;
   19750             :                 } else {
   19751           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   19752             :                           PyLong_Type.tp_name);
   19753           0 :                         return -1;
   19754             :                 }
   19755             :         }
   19756           0 :         return 0;
   19757             : }
   19758             : 
   19759           0 : static PyObject *py_DNS_RPC_ZONE_DATABASE_DOTNET_get_dwReserved0(PyObject *obj, void *closure)
   19760             : {
   19761           0 :         struct DNS_RPC_ZONE_DATABASE_DOTNET *object = pytalloc_get_ptr(obj);
   19762           0 :         PyObject *py_dwReserved0;
   19763           0 :         py_dwReserved0 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved0));
   19764           0 :         return py_dwReserved0;
   19765             : }
   19766             : 
   19767           0 : static int py_DNS_RPC_ZONE_DATABASE_DOTNET_set_dwReserved0(PyObject *py_obj, PyObject *value, void *closure)
   19768             : {
   19769           0 :         struct DNS_RPC_ZONE_DATABASE_DOTNET *object = pytalloc_get_ptr(py_obj);
   19770           0 :         if (value == NULL) {
   19771           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved0");
   19772           0 :                 return -1;
   19773             :         }
   19774             :         {
   19775           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved0));
   19776           0 :                 if (PyLong_Check(value)) {
   19777           0 :                         unsigned long long test_var;
   19778           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   19779           0 :                         if (PyErr_Occurred() != NULL) {
   19780           0 :                                 return -1;
   19781             :                         }
   19782           0 :                         if (test_var > uint_max) {
   19783           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   19784             :                                   PyLong_Type.tp_name, uint_max, test_var);
   19785           0 :                                 return -1;
   19786             :                         }
   19787           0 :                         object->dwReserved0 = test_var;
   19788             :                 } else {
   19789           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   19790             :                           PyLong_Type.tp_name);
   19791           0 :                         return -1;
   19792             :                 }
   19793             :         }
   19794           0 :         return 0;
   19795             : }
   19796             : 
   19797           0 : static PyObject *py_DNS_RPC_ZONE_DATABASE_DOTNET_get_fDsIntegrated(PyObject *obj, void *closure)
   19798             : {
   19799           0 :         struct DNS_RPC_ZONE_DATABASE_DOTNET *object = pytalloc_get_ptr(obj);
   19800           0 :         PyObject *py_fDsIntegrated;
   19801           0 :         py_fDsIntegrated = PyLong_FromUnsignedLongLong((uint32_t)(object->fDsIntegrated));
   19802           0 :         return py_fDsIntegrated;
   19803             : }
   19804             : 
   19805           0 : static int py_DNS_RPC_ZONE_DATABASE_DOTNET_set_fDsIntegrated(PyObject *py_obj, PyObject *value, void *closure)
   19806             : {
   19807           0 :         struct DNS_RPC_ZONE_DATABASE_DOTNET *object = pytalloc_get_ptr(py_obj);
   19808           0 :         if (value == NULL) {
   19809           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fDsIntegrated");
   19810           0 :                 return -1;
   19811             :         }
   19812             :         {
   19813           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fDsIntegrated));
   19814           0 :                 if (PyLong_Check(value)) {
   19815           0 :                         unsigned long long test_var;
   19816           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   19817           0 :                         if (PyErr_Occurred() != NULL) {
   19818           0 :                                 return -1;
   19819             :                         }
   19820           0 :                         if (test_var > uint_max) {
   19821           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   19822             :                                   PyLong_Type.tp_name, uint_max, test_var);
   19823           0 :                                 return -1;
   19824             :                         }
   19825           0 :                         object->fDsIntegrated = test_var;
   19826             :                 } else {
   19827           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   19828             :                           PyLong_Type.tp_name);
   19829           0 :                         return -1;
   19830             :                 }
   19831             :         }
   19832           0 :         return 0;
   19833             : }
   19834             : 
   19835           0 : static PyObject *py_DNS_RPC_ZONE_DATABASE_DOTNET_get_pszFileName(PyObject *obj, void *closure)
   19836             : {
   19837           0 :         struct DNS_RPC_ZONE_DATABASE_DOTNET *object = pytalloc_get_ptr(obj);
   19838           0 :         PyObject *py_pszFileName;
   19839           0 :         if (object->pszFileName == NULL) {
   19840           0 :                 Py_RETURN_NONE;
   19841             :         }
   19842           0 :         if (object->pszFileName == NULL) {
   19843           0 :                 py_pszFileName = Py_None;
   19844           0 :                 Py_INCREF(py_pszFileName);
   19845             :         } else {
   19846           0 :                 if (object->pszFileName == NULL) {
   19847           0 :                         py_pszFileName = Py_None;
   19848           0 :                         Py_INCREF(py_pszFileName);
   19849             :                 } else {
   19850           0 :                         py_pszFileName = PyUnicode_Decode(object->pszFileName, strlen(object->pszFileName), "utf-8", "ignore");
   19851             :                 }
   19852             :         }
   19853           0 :         return py_pszFileName;
   19854             : }
   19855             : 
   19856           0 : static int py_DNS_RPC_ZONE_DATABASE_DOTNET_set_pszFileName(PyObject *py_obj, PyObject *value, void *closure)
   19857             : {
   19858           0 :         struct DNS_RPC_ZONE_DATABASE_DOTNET *object = pytalloc_get_ptr(py_obj);
   19859           0 :         if (value == NULL) {
   19860           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszFileName");
   19861           0 :                 return -1;
   19862             :         }
   19863           0 :         if (value == Py_None) {
   19864           0 :                 object->pszFileName = NULL;
   19865             :         } else {
   19866           0 :                 object->pszFileName = NULL;
   19867             :                 {
   19868           0 :                         const char *test_str;
   19869           0 :                         const char *talloc_str;
   19870           0 :                         PyObject *unicode = NULL;
   19871           0 :                         if (PyUnicode_Check(value)) {
   19872           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   19873           0 :                                 if (unicode == NULL) {
   19874           0 :                                         return -1;
   19875             :                                 }
   19876           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   19877           0 :                         } else if (PyBytes_Check(value)) {
   19878           0 :                                 test_str = PyBytes_AS_STRING(value);
   19879             :                         } else {
   19880           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   19881           0 :                                 return -1;
   19882             :                         }
   19883           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   19884           0 :                         if (unicode != NULL) {
   19885           0 :                                 Py_DECREF(unicode);
   19886             :                         }
   19887           0 :                         if (talloc_str == NULL) {
   19888           0 :                                 PyErr_NoMemory();
   19889           0 :                                 return -1;
   19890             :                         }
   19891           0 :                         object->pszFileName = talloc_str;
   19892             :                 }
   19893             :         }
   19894           0 :         return 0;
   19895             : }
   19896             : 
   19897             : static PyGetSetDef py_DNS_RPC_ZONE_DATABASE_DOTNET_getsetters[] = {
   19898             :         {
   19899             :                 .name = discard_const_p(char, "dwRpcStructureVersion"),
   19900             :                 .get = py_DNS_RPC_ZONE_DATABASE_DOTNET_get_dwRpcStructureVersion,
   19901             :                 .set = py_DNS_RPC_ZONE_DATABASE_DOTNET_set_dwRpcStructureVersion,
   19902             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   19903             :         },
   19904             :         {
   19905             :                 .name = discard_const_p(char, "dwReserved0"),
   19906             :                 .get = py_DNS_RPC_ZONE_DATABASE_DOTNET_get_dwReserved0,
   19907             :                 .set = py_DNS_RPC_ZONE_DATABASE_DOTNET_set_dwReserved0,
   19908             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   19909             :         },
   19910             :         {
   19911             :                 .name = discard_const_p(char, "fDsIntegrated"),
   19912             :                 .get = py_DNS_RPC_ZONE_DATABASE_DOTNET_get_fDsIntegrated,
   19913             :                 .set = py_DNS_RPC_ZONE_DATABASE_DOTNET_set_fDsIntegrated,
   19914             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   19915             :         },
   19916             :         {
   19917             :                 .name = discard_const_p(char, "pszFileName"),
   19918             :                 .get = py_DNS_RPC_ZONE_DATABASE_DOTNET_get_pszFileName,
   19919             :                 .set = py_DNS_RPC_ZONE_DATABASE_DOTNET_set_pszFileName,
   19920             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   19921             :         },
   19922             :         { .name = NULL }
   19923             : };
   19924             : 
   19925           0 : static PyObject *py_DNS_RPC_ZONE_DATABASE_DOTNET_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   19926             : {
   19927           0 :         return pytalloc_new(struct DNS_RPC_ZONE_DATABASE_DOTNET, type);
   19928             : }
   19929             : 
   19930             : 
   19931             : static PyTypeObject DNS_RPC_ZONE_DATABASE_DOTNET_Type = {
   19932             :         PyVarObject_HEAD_INIT(NULL, 0)
   19933             :         .tp_name = "dnsserver.DNS_RPC_ZONE_DATABASE_DOTNET",
   19934             :         .tp_getset = py_DNS_RPC_ZONE_DATABASE_DOTNET_getsetters,
   19935             :         .tp_methods = NULL,
   19936             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   19937             :         .tp_new = py_DNS_RPC_ZONE_DATABASE_DOTNET_new,
   19938             : };
   19939             : 
   19940             : 
   19941           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_pszZoneName(PyObject *obj, void *closure)
   19942             : {
   19943           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   19944           0 :         PyObject *py_pszZoneName;
   19945           0 :         if (object->pszZoneName == NULL) {
   19946           0 :                 Py_RETURN_NONE;
   19947             :         }
   19948           0 :         if (object->pszZoneName == NULL) {
   19949           0 :                 py_pszZoneName = Py_None;
   19950           0 :                 Py_INCREF(py_pszZoneName);
   19951             :         } else {
   19952           0 :                 if (object->pszZoneName == NULL) {
   19953           0 :                         py_pszZoneName = Py_None;
   19954           0 :                         Py_INCREF(py_pszZoneName);
   19955             :                 } else {
   19956           0 :                         py_pszZoneName = PyUnicode_Decode(object->pszZoneName, strlen(object->pszZoneName), "utf-8", "ignore");
   19957             :                 }
   19958             :         }
   19959           0 :         return py_pszZoneName;
   19960             : }
   19961             : 
   19962           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_pszZoneName(PyObject *py_obj, PyObject *value, void *closure)
   19963             : {
   19964           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   19965           0 :         if (value == NULL) {
   19966           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszZoneName");
   19967           0 :                 return -1;
   19968             :         }
   19969           0 :         if (value == Py_None) {
   19970           0 :                 object->pszZoneName = NULL;
   19971             :         } else {
   19972           0 :                 object->pszZoneName = NULL;
   19973             :                 {
   19974           0 :                         const char *test_str;
   19975           0 :                         const char *talloc_str;
   19976           0 :                         PyObject *unicode = NULL;
   19977           0 :                         if (PyUnicode_Check(value)) {
   19978           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   19979           0 :                                 if (unicode == NULL) {
   19980           0 :                                         return -1;
   19981             :                                 }
   19982           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   19983           0 :                         } else if (PyBytes_Check(value)) {
   19984           0 :                                 test_str = PyBytes_AS_STRING(value);
   19985             :                         } else {
   19986           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   19987           0 :                                 return -1;
   19988             :                         }
   19989           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   19990           0 :                         if (unicode != NULL) {
   19991           0 :                                 Py_DECREF(unicode);
   19992             :                         }
   19993           0 :                         if (talloc_str == NULL) {
   19994           0 :                                 PyErr_NoMemory();
   19995           0 :                                 return -1;
   19996             :                         }
   19997           0 :                         object->pszZoneName = talloc_str;
   19998             :                 }
   19999             :         }
   20000           0 :         return 0;
   20001             : }
   20002             : 
   20003           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_dwZoneType(PyObject *obj, void *closure)
   20004             : {
   20005           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   20006           0 :         PyObject *py_dwZoneType;
   20007           0 :         py_dwZoneType = PyLong_FromUnsignedLongLong((uint32_t)(object->dwZoneType));
   20008           0 :         return py_dwZoneType;
   20009             : }
   20010             : 
   20011           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_dwZoneType(PyObject *py_obj, PyObject *value, void *closure)
   20012             : {
   20013           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   20014           0 :         if (value == NULL) {
   20015           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwZoneType");
   20016           0 :                 return -1;
   20017             :         }
   20018             :         {
   20019           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwZoneType));
   20020           0 :                 if (PyLong_Check(value)) {
   20021           0 :                         unsigned long long test_var;
   20022           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   20023           0 :                         if (PyErr_Occurred() != NULL) {
   20024           0 :                                 return -1;
   20025             :                         }
   20026           0 :                         if (test_var > uint_max) {
   20027           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   20028             :                                   PyLong_Type.tp_name, uint_max, test_var);
   20029           0 :                                 return -1;
   20030             :                         }
   20031           0 :                         object->dwZoneType = test_var;
   20032             :                 } else {
   20033           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   20034             :                           PyLong_Type.tp_name);
   20035           0 :                         return -1;
   20036             :                 }
   20037             :         }
   20038           0 :         return 0;
   20039             : }
   20040             : 
   20041           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_fAllowUpdate(PyObject *obj, void *closure)
   20042             : {
   20043           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   20044           0 :         PyObject *py_fAllowUpdate;
   20045           0 :         py_fAllowUpdate = PyLong_FromLong((uint16_t)(object->fAllowUpdate));
   20046           0 :         return py_fAllowUpdate;
   20047             : }
   20048             : 
   20049           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_fAllowUpdate(PyObject *py_obj, PyObject *value, void *closure)
   20050             : {
   20051           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   20052           0 :         if (value == NULL) {
   20053           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAllowUpdate");
   20054           0 :                 return -1;
   20055             :         }
   20056             :         {
   20057           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAllowUpdate));
   20058           0 :                 if (PyLong_Check(value)) {
   20059           0 :                         unsigned long long test_var;
   20060           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   20061           0 :                         if (PyErr_Occurred() != NULL) {
   20062           0 :                                 return -1;
   20063             :                         }
   20064           0 :                         if (test_var > uint_max) {
   20065           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   20066             :                                   PyLong_Type.tp_name, uint_max, test_var);
   20067           0 :                                 return -1;
   20068             :                         }
   20069           0 :                         object->fAllowUpdate = test_var;
   20070             :                 } else {
   20071           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   20072             :                           PyLong_Type.tp_name);
   20073           0 :                         return -1;
   20074             :                 }
   20075             :         }
   20076           0 :         return 0;
   20077             : }
   20078             : 
   20079           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_fAging(PyObject *obj, void *closure)
   20080             : {
   20081           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   20082           0 :         PyObject *py_fAging;
   20083           0 :         py_fAging = PyLong_FromUnsignedLongLong((uint32_t)(object->fAging));
   20084           0 :         return py_fAging;
   20085             : }
   20086             : 
   20087           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_fAging(PyObject *py_obj, PyObject *value, void *closure)
   20088             : {
   20089           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   20090           0 :         if (value == NULL) {
   20091           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAging");
   20092           0 :                 return -1;
   20093             :         }
   20094             :         {
   20095           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAging));
   20096           0 :                 if (PyLong_Check(value)) {
   20097           0 :                         unsigned long long test_var;
   20098           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   20099           0 :                         if (PyErr_Occurred() != NULL) {
   20100           0 :                                 return -1;
   20101             :                         }
   20102           0 :                         if (test_var > uint_max) {
   20103           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   20104             :                                   PyLong_Type.tp_name, uint_max, test_var);
   20105           0 :                                 return -1;
   20106             :                         }
   20107           0 :                         object->fAging = test_var;
   20108             :                 } else {
   20109           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   20110             :                           PyLong_Type.tp_name);
   20111           0 :                         return -1;
   20112             :                 }
   20113             :         }
   20114           0 :         return 0;
   20115             : }
   20116             : 
   20117           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_dwFlags(PyObject *obj, void *closure)
   20118             : {
   20119           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   20120           0 :         PyObject *py_dwFlags;
   20121           0 :         py_dwFlags = PyLong_FromUnsignedLongLong((uint32_t)(object->dwFlags));
   20122           0 :         return py_dwFlags;
   20123             : }
   20124             : 
   20125           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_dwFlags(PyObject *py_obj, PyObject *value, void *closure)
   20126             : {
   20127           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   20128           0 :         if (value == NULL) {
   20129           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwFlags");
   20130           0 :                 return -1;
   20131             :         }
   20132             :         {
   20133           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwFlags));
   20134           0 :                 if (PyLong_Check(value)) {
   20135           0 :                         unsigned long long test_var;
   20136           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   20137           0 :                         if (PyErr_Occurred() != NULL) {
   20138           0 :                                 return -1;
   20139             :                         }
   20140           0 :                         if (test_var > uint_max) {
   20141           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   20142             :                                   PyLong_Type.tp_name, uint_max, test_var);
   20143           0 :                                 return -1;
   20144             :                         }
   20145           0 :                         object->dwFlags = test_var;
   20146             :                 } else {
   20147           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   20148             :                           PyLong_Type.tp_name);
   20149           0 :                         return -1;
   20150             :                 }
   20151             :         }
   20152           0 :         return 0;
   20153             : }
   20154             : 
   20155           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_pszDataFile(PyObject *obj, void *closure)
   20156             : {
   20157           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   20158           0 :         PyObject *py_pszDataFile;
   20159           0 :         if (object->pszDataFile == NULL) {
   20160           0 :                 Py_RETURN_NONE;
   20161             :         }
   20162           0 :         if (object->pszDataFile == NULL) {
   20163           0 :                 py_pszDataFile = Py_None;
   20164           0 :                 Py_INCREF(py_pszDataFile);
   20165             :         } else {
   20166           0 :                 if (object->pszDataFile == NULL) {
   20167           0 :                         py_pszDataFile = Py_None;
   20168           0 :                         Py_INCREF(py_pszDataFile);
   20169             :                 } else {
   20170           0 :                         py_pszDataFile = PyUnicode_Decode(object->pszDataFile, strlen(object->pszDataFile), "utf-8", "ignore");
   20171             :                 }
   20172             :         }
   20173           0 :         return py_pszDataFile;
   20174             : }
   20175             : 
   20176           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_pszDataFile(PyObject *py_obj, PyObject *value, void *closure)
   20177             : {
   20178           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   20179           0 :         if (value == NULL) {
   20180           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszDataFile");
   20181           0 :                 return -1;
   20182             :         }
   20183           0 :         if (value == Py_None) {
   20184           0 :                 object->pszDataFile = NULL;
   20185             :         } else {
   20186           0 :                 object->pszDataFile = NULL;
   20187             :                 {
   20188           0 :                         const char *test_str;
   20189           0 :                         const char *talloc_str;
   20190           0 :                         PyObject *unicode = NULL;
   20191           0 :                         if (PyUnicode_Check(value)) {
   20192           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   20193           0 :                                 if (unicode == NULL) {
   20194           0 :                                         return -1;
   20195             :                                 }
   20196           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   20197           0 :                         } else if (PyBytes_Check(value)) {
   20198           0 :                                 test_str = PyBytes_AS_STRING(value);
   20199             :                         } else {
   20200           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   20201           0 :                                 return -1;
   20202             :                         }
   20203           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   20204           0 :                         if (unicode != NULL) {
   20205           0 :                                 Py_DECREF(unicode);
   20206             :                         }
   20207           0 :                         if (talloc_str == NULL) {
   20208           0 :                                 PyErr_NoMemory();
   20209           0 :                                 return -1;
   20210             :                         }
   20211           0 :                         object->pszDataFile = talloc_str;
   20212             :                 }
   20213             :         }
   20214           0 :         return 0;
   20215             : }
   20216             : 
   20217           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_fDsIntegrated(PyObject *obj, void *closure)
   20218             : {
   20219           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   20220           0 :         PyObject *py_fDsIntegrated;
   20221           0 :         py_fDsIntegrated = PyLong_FromUnsignedLongLong((uint32_t)(object->fDsIntegrated));
   20222           0 :         return py_fDsIntegrated;
   20223             : }
   20224             : 
   20225           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_fDsIntegrated(PyObject *py_obj, PyObject *value, void *closure)
   20226             : {
   20227           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   20228           0 :         if (value == NULL) {
   20229           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fDsIntegrated");
   20230           0 :                 return -1;
   20231             :         }
   20232             :         {
   20233           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fDsIntegrated));
   20234           0 :                 if (PyLong_Check(value)) {
   20235           0 :                         unsigned long long test_var;
   20236           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   20237           0 :                         if (PyErr_Occurred() != NULL) {
   20238           0 :                                 return -1;
   20239             :                         }
   20240           0 :                         if (test_var > uint_max) {
   20241           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   20242             :                                   PyLong_Type.tp_name, uint_max, test_var);
   20243           0 :                                 return -1;
   20244             :                         }
   20245           0 :                         object->fDsIntegrated = test_var;
   20246             :                 } else {
   20247           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   20248             :                           PyLong_Type.tp_name);
   20249           0 :                         return -1;
   20250             :                 }
   20251             :         }
   20252           0 :         return 0;
   20253             : }
   20254             : 
   20255           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_fLoadExisting(PyObject *obj, void *closure)
   20256             : {
   20257           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   20258           0 :         PyObject *py_fLoadExisting;
   20259           0 :         py_fLoadExisting = PyLong_FromUnsignedLongLong((uint32_t)(object->fLoadExisting));
   20260           0 :         return py_fLoadExisting;
   20261             : }
   20262             : 
   20263           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_fLoadExisting(PyObject *py_obj, PyObject *value, void *closure)
   20264             : {
   20265           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   20266           0 :         if (value == NULL) {
   20267           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fLoadExisting");
   20268           0 :                 return -1;
   20269             :         }
   20270             :         {
   20271           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fLoadExisting));
   20272           0 :                 if (PyLong_Check(value)) {
   20273           0 :                         unsigned long long test_var;
   20274           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   20275           0 :                         if (PyErr_Occurred() != NULL) {
   20276           0 :                                 return -1;
   20277             :                         }
   20278           0 :                         if (test_var > uint_max) {
   20279           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   20280             :                                   PyLong_Type.tp_name, uint_max, test_var);
   20281           0 :                                 return -1;
   20282             :                         }
   20283           0 :                         object->fLoadExisting = test_var;
   20284             :                 } else {
   20285           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   20286             :                           PyLong_Type.tp_name);
   20287           0 :                         return -1;
   20288             :                 }
   20289             :         }
   20290           0 :         return 0;
   20291             : }
   20292             : 
   20293           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_pszAdmin(PyObject *obj, void *closure)
   20294             : {
   20295           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   20296           0 :         PyObject *py_pszAdmin;
   20297           0 :         if (object->pszAdmin == NULL) {
   20298           0 :                 Py_RETURN_NONE;
   20299             :         }
   20300           0 :         if (object->pszAdmin == NULL) {
   20301           0 :                 py_pszAdmin = Py_None;
   20302           0 :                 Py_INCREF(py_pszAdmin);
   20303             :         } else {
   20304           0 :                 if (object->pszAdmin == NULL) {
   20305           0 :                         py_pszAdmin = Py_None;
   20306           0 :                         Py_INCREF(py_pszAdmin);
   20307             :                 } else {
   20308           0 :                         py_pszAdmin = PyUnicode_Decode(object->pszAdmin, strlen(object->pszAdmin), "utf-8", "ignore");
   20309             :                 }
   20310             :         }
   20311           0 :         return py_pszAdmin;
   20312             : }
   20313             : 
   20314           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_pszAdmin(PyObject *py_obj, PyObject *value, void *closure)
   20315             : {
   20316           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   20317           0 :         if (value == NULL) {
   20318           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszAdmin");
   20319           0 :                 return -1;
   20320             :         }
   20321           0 :         if (value == Py_None) {
   20322           0 :                 object->pszAdmin = NULL;
   20323             :         } else {
   20324           0 :                 object->pszAdmin = NULL;
   20325             :                 {
   20326           0 :                         const char *test_str;
   20327           0 :                         const char *talloc_str;
   20328           0 :                         PyObject *unicode = NULL;
   20329           0 :                         if (PyUnicode_Check(value)) {
   20330           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   20331           0 :                                 if (unicode == NULL) {
   20332           0 :                                         return -1;
   20333             :                                 }
   20334           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   20335           0 :                         } else if (PyBytes_Check(value)) {
   20336           0 :                                 test_str = PyBytes_AS_STRING(value);
   20337             :                         } else {
   20338           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   20339           0 :                                 return -1;
   20340             :                         }
   20341           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   20342           0 :                         if (unicode != NULL) {
   20343           0 :                                 Py_DECREF(unicode);
   20344             :                         }
   20345           0 :                         if (talloc_str == NULL) {
   20346           0 :                                 PyErr_NoMemory();
   20347           0 :                                 return -1;
   20348             :                         }
   20349           0 :                         object->pszAdmin = talloc_str;
   20350             :                 }
   20351             :         }
   20352           0 :         return 0;
   20353             : }
   20354             : 
   20355           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_aipMasters(PyObject *obj, void *closure)
   20356             : {
   20357           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   20358           0 :         PyObject *py_aipMasters;
   20359           0 :         if (object->aipMasters == NULL) {
   20360           0 :                 Py_RETURN_NONE;
   20361             :         }
   20362           0 :         if (object->aipMasters == NULL) {
   20363           0 :                 py_aipMasters = Py_None;
   20364           0 :                 Py_INCREF(py_aipMasters);
   20365             :         } else {
   20366           0 :                 py_aipMasters = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipMasters, object->aipMasters);
   20367             :         }
   20368           0 :         return py_aipMasters;
   20369             : }
   20370             : 
   20371           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_aipMasters(PyObject *py_obj, PyObject *value, void *closure)
   20372             : {
   20373           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   20374           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipMasters));
   20375           0 :         if (value == NULL) {
   20376           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipMasters");
   20377           0 :                 return -1;
   20378             :         }
   20379           0 :         if (value == Py_None) {
   20380           0 :                 object->aipMasters = NULL;
   20381             :         } else {
   20382           0 :                 object->aipMasters = NULL;
   20383           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
   20384           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   20385           0 :                         PyErr_NoMemory();
   20386           0 :                         return -1;
   20387             :                 }
   20388           0 :                 object->aipMasters = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
   20389             :         }
   20390           0 :         return 0;
   20391             : }
   20392             : 
   20393           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_aipSecondaries(PyObject *obj, void *closure)
   20394             : {
   20395           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   20396           0 :         PyObject *py_aipSecondaries;
   20397           0 :         if (object->aipSecondaries == NULL) {
   20398           0 :                 Py_RETURN_NONE;
   20399             :         }
   20400           0 :         if (object->aipSecondaries == NULL) {
   20401           0 :                 py_aipSecondaries = Py_None;
   20402           0 :                 Py_INCREF(py_aipSecondaries);
   20403             :         } else {
   20404           0 :                 py_aipSecondaries = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipSecondaries, object->aipSecondaries);
   20405             :         }
   20406           0 :         return py_aipSecondaries;
   20407             : }
   20408             : 
   20409           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_aipSecondaries(PyObject *py_obj, PyObject *value, void *closure)
   20410             : {
   20411           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   20412           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipSecondaries));
   20413           0 :         if (value == NULL) {
   20414           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipSecondaries");
   20415           0 :                 return -1;
   20416             :         }
   20417           0 :         if (value == Py_None) {
   20418           0 :                 object->aipSecondaries = NULL;
   20419             :         } else {
   20420           0 :                 object->aipSecondaries = NULL;
   20421           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
   20422           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   20423           0 :                         PyErr_NoMemory();
   20424           0 :                         return -1;
   20425             :                 }
   20426           0 :                 object->aipSecondaries = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
   20427             :         }
   20428           0 :         return 0;
   20429             : }
   20430             : 
   20431           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_fSecureSecondaries(PyObject *obj, void *closure)
   20432             : {
   20433           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   20434           0 :         PyObject *py_fSecureSecondaries;
   20435           0 :         py_fSecureSecondaries = PyLong_FromUnsignedLongLong((uint32_t)(object->fSecureSecondaries));
   20436           0 :         return py_fSecureSecondaries;
   20437             : }
   20438             : 
   20439           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_fSecureSecondaries(PyObject *py_obj, PyObject *value, void *closure)
   20440             : {
   20441           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   20442           0 :         if (value == NULL) {
   20443           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fSecureSecondaries");
   20444           0 :                 return -1;
   20445             :         }
   20446             :         {
   20447           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fSecureSecondaries));
   20448           0 :                 if (PyLong_Check(value)) {
   20449           0 :                         unsigned long long test_var;
   20450           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   20451           0 :                         if (PyErr_Occurred() != NULL) {
   20452           0 :                                 return -1;
   20453             :                         }
   20454           0 :                         if (test_var > uint_max) {
   20455           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   20456             :                                   PyLong_Type.tp_name, uint_max, test_var);
   20457           0 :                                 return -1;
   20458             :                         }
   20459           0 :                         object->fSecureSecondaries = test_var;
   20460             :                 } else {
   20461           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   20462             :                           PyLong_Type.tp_name);
   20463           0 :                         return -1;
   20464             :                 }
   20465             :         }
   20466           0 :         return 0;
   20467             : }
   20468             : 
   20469           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_fNotifyLevel(PyObject *obj, void *closure)
   20470             : {
   20471           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   20472           0 :         PyObject *py_fNotifyLevel;
   20473           0 :         py_fNotifyLevel = PyLong_FromUnsignedLongLong((uint32_t)(object->fNotifyLevel));
   20474           0 :         return py_fNotifyLevel;
   20475             : }
   20476             : 
   20477           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_fNotifyLevel(PyObject *py_obj, PyObject *value, void *closure)
   20478             : {
   20479           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   20480           0 :         if (value == NULL) {
   20481           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fNotifyLevel");
   20482           0 :                 return -1;
   20483             :         }
   20484             :         {
   20485           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fNotifyLevel));
   20486           0 :                 if (PyLong_Check(value)) {
   20487           0 :                         unsigned long long test_var;
   20488           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   20489           0 :                         if (PyErr_Occurred() != NULL) {
   20490           0 :                                 return -1;
   20491             :                         }
   20492           0 :                         if (test_var > uint_max) {
   20493           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   20494             :                                   PyLong_Type.tp_name, uint_max, test_var);
   20495           0 :                                 return -1;
   20496             :                         }
   20497           0 :                         object->fNotifyLevel = test_var;
   20498             :                 } else {
   20499           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   20500             :                           PyLong_Type.tp_name);
   20501           0 :                         return -1;
   20502             :                 }
   20503             :         }
   20504           0 :         return 0;
   20505             : }
   20506             : 
   20507           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_pvReserved1(PyObject *obj, void *closure)
   20508             : {
   20509           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   20510           0 :         PyObject *py_pvReserved1;
   20511           0 :         if (object->pvReserved1 == NULL) {
   20512           0 :                 Py_RETURN_NONE;
   20513             :         }
   20514           0 :         if (object->pvReserved1 == NULL) {
   20515           0 :                 py_pvReserved1 = Py_None;
   20516           0 :                 Py_INCREF(py_pvReserved1);
   20517             :         } else {
   20518           0 :                 if (object->pvReserved1 == NULL) {
   20519           0 :                         py_pvReserved1 = Py_None;
   20520           0 :                         Py_INCREF(py_pvReserved1);
   20521             :                 } else {
   20522           0 :                         py_pvReserved1 = PyUnicode_Decode(object->pvReserved1, strlen(object->pvReserved1), "utf-8", "ignore");
   20523             :                 }
   20524             :         }
   20525           0 :         return py_pvReserved1;
   20526             : }
   20527             : 
   20528           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_pvReserved1(PyObject *py_obj, PyObject *value, void *closure)
   20529             : {
   20530           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   20531           0 :         if (value == NULL) {
   20532           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pvReserved1");
   20533           0 :                 return -1;
   20534             :         }
   20535           0 :         if (value == Py_None) {
   20536           0 :                 object->pvReserved1 = NULL;
   20537             :         } else {
   20538           0 :                 object->pvReserved1 = NULL;
   20539             :                 {
   20540           0 :                         const char *test_str;
   20541           0 :                         const char *talloc_str;
   20542           0 :                         PyObject *unicode = NULL;
   20543           0 :                         if (PyUnicode_Check(value)) {
   20544           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   20545           0 :                                 if (unicode == NULL) {
   20546           0 :                                         return -1;
   20547             :                                 }
   20548           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   20549           0 :                         } else if (PyBytes_Check(value)) {
   20550           0 :                                 test_str = PyBytes_AS_STRING(value);
   20551             :                         } else {
   20552           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   20553           0 :                                 return -1;
   20554             :                         }
   20555           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   20556           0 :                         if (unicode != NULL) {
   20557           0 :                                 Py_DECREF(unicode);
   20558             :                         }
   20559           0 :                         if (talloc_str == NULL) {
   20560           0 :                                 PyErr_NoMemory();
   20561           0 :                                 return -1;
   20562             :                         }
   20563           0 :                         object->pvReserved1 = talloc_str;
   20564             :                 }
   20565             :         }
   20566           0 :         return 0;
   20567             : }
   20568             : 
   20569           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_pvReserved2(PyObject *obj, void *closure)
   20570             : {
   20571           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   20572           0 :         PyObject *py_pvReserved2;
   20573           0 :         if (object->pvReserved2 == NULL) {
   20574           0 :                 Py_RETURN_NONE;
   20575             :         }
   20576           0 :         if (object->pvReserved2 == NULL) {
   20577           0 :                 py_pvReserved2 = Py_None;
   20578           0 :                 Py_INCREF(py_pvReserved2);
   20579             :         } else {
   20580           0 :                 if (object->pvReserved2 == NULL) {
   20581           0 :                         py_pvReserved2 = Py_None;
   20582           0 :                         Py_INCREF(py_pvReserved2);
   20583             :                 } else {
   20584           0 :                         py_pvReserved2 = PyUnicode_Decode(object->pvReserved2, strlen(object->pvReserved2), "utf-8", "ignore");
   20585             :                 }
   20586             :         }
   20587           0 :         return py_pvReserved2;
   20588             : }
   20589             : 
   20590           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_pvReserved2(PyObject *py_obj, PyObject *value, void *closure)
   20591             : {
   20592           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   20593           0 :         if (value == NULL) {
   20594           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pvReserved2");
   20595           0 :                 return -1;
   20596             :         }
   20597           0 :         if (value == Py_None) {
   20598           0 :                 object->pvReserved2 = NULL;
   20599             :         } else {
   20600           0 :                 object->pvReserved2 = NULL;
   20601             :                 {
   20602           0 :                         const char *test_str;
   20603           0 :                         const char *talloc_str;
   20604           0 :                         PyObject *unicode = NULL;
   20605           0 :                         if (PyUnicode_Check(value)) {
   20606           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   20607           0 :                                 if (unicode == NULL) {
   20608           0 :                                         return -1;
   20609             :                                 }
   20610           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   20611           0 :                         } else if (PyBytes_Check(value)) {
   20612           0 :                                 test_str = PyBytes_AS_STRING(value);
   20613             :                         } else {
   20614           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   20615           0 :                                 return -1;
   20616             :                         }
   20617           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   20618           0 :                         if (unicode != NULL) {
   20619           0 :                                 Py_DECREF(unicode);
   20620             :                         }
   20621           0 :                         if (talloc_str == NULL) {
   20622           0 :                                 PyErr_NoMemory();
   20623           0 :                                 return -1;
   20624             :                         }
   20625           0 :                         object->pvReserved2 = talloc_str;
   20626             :                 }
   20627             :         }
   20628           0 :         return 0;
   20629             : }
   20630             : 
   20631           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_pvReserved3(PyObject *obj, void *closure)
   20632             : {
   20633           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   20634           0 :         PyObject *py_pvReserved3;
   20635           0 :         if (object->pvReserved3 == NULL) {
   20636           0 :                 Py_RETURN_NONE;
   20637             :         }
   20638           0 :         if (object->pvReserved3 == NULL) {
   20639           0 :                 py_pvReserved3 = Py_None;
   20640           0 :                 Py_INCREF(py_pvReserved3);
   20641             :         } else {
   20642           0 :                 if (object->pvReserved3 == NULL) {
   20643           0 :                         py_pvReserved3 = Py_None;
   20644           0 :                         Py_INCREF(py_pvReserved3);
   20645             :                 } else {
   20646           0 :                         py_pvReserved3 = PyUnicode_Decode(object->pvReserved3, strlen(object->pvReserved3), "utf-8", "ignore");
   20647             :                 }
   20648             :         }
   20649           0 :         return py_pvReserved3;
   20650             : }
   20651             : 
   20652           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_pvReserved3(PyObject *py_obj, PyObject *value, void *closure)
   20653             : {
   20654           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   20655           0 :         if (value == NULL) {
   20656           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pvReserved3");
   20657           0 :                 return -1;
   20658             :         }
   20659           0 :         if (value == Py_None) {
   20660           0 :                 object->pvReserved3 = NULL;
   20661             :         } else {
   20662           0 :                 object->pvReserved3 = NULL;
   20663             :                 {
   20664           0 :                         const char *test_str;
   20665           0 :                         const char *talloc_str;
   20666           0 :                         PyObject *unicode = NULL;
   20667           0 :                         if (PyUnicode_Check(value)) {
   20668           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   20669           0 :                                 if (unicode == NULL) {
   20670           0 :                                         return -1;
   20671             :                                 }
   20672           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   20673           0 :                         } else if (PyBytes_Check(value)) {
   20674           0 :                                 test_str = PyBytes_AS_STRING(value);
   20675             :                         } else {
   20676           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   20677           0 :                                 return -1;
   20678             :                         }
   20679           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   20680           0 :                         if (unicode != NULL) {
   20681           0 :                                 Py_DECREF(unicode);
   20682             :                         }
   20683           0 :                         if (talloc_str == NULL) {
   20684           0 :                                 PyErr_NoMemory();
   20685           0 :                                 return -1;
   20686             :                         }
   20687           0 :                         object->pvReserved3 = talloc_str;
   20688             :                 }
   20689             :         }
   20690           0 :         return 0;
   20691             : }
   20692             : 
   20693           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_pvReserved4(PyObject *obj, void *closure)
   20694             : {
   20695           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   20696           0 :         PyObject *py_pvReserved4;
   20697           0 :         if (object->pvReserved4 == NULL) {
   20698           0 :                 Py_RETURN_NONE;
   20699             :         }
   20700           0 :         if (object->pvReserved4 == NULL) {
   20701           0 :                 py_pvReserved4 = Py_None;
   20702           0 :                 Py_INCREF(py_pvReserved4);
   20703             :         } else {
   20704           0 :                 if (object->pvReserved4 == NULL) {
   20705           0 :                         py_pvReserved4 = Py_None;
   20706           0 :                         Py_INCREF(py_pvReserved4);
   20707             :                 } else {
   20708           0 :                         py_pvReserved4 = PyUnicode_Decode(object->pvReserved4, strlen(object->pvReserved4), "utf-8", "ignore");
   20709             :                 }
   20710             :         }
   20711           0 :         return py_pvReserved4;
   20712             : }
   20713             : 
   20714           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_pvReserved4(PyObject *py_obj, PyObject *value, void *closure)
   20715             : {
   20716           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   20717           0 :         if (value == NULL) {
   20718           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pvReserved4");
   20719           0 :                 return -1;
   20720             :         }
   20721           0 :         if (value == Py_None) {
   20722           0 :                 object->pvReserved4 = NULL;
   20723             :         } else {
   20724           0 :                 object->pvReserved4 = NULL;
   20725             :                 {
   20726           0 :                         const char *test_str;
   20727           0 :                         const char *talloc_str;
   20728           0 :                         PyObject *unicode = NULL;
   20729           0 :                         if (PyUnicode_Check(value)) {
   20730           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   20731           0 :                                 if (unicode == NULL) {
   20732           0 :                                         return -1;
   20733             :                                 }
   20734           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   20735           0 :                         } else if (PyBytes_Check(value)) {
   20736           0 :                                 test_str = PyBytes_AS_STRING(value);
   20737             :                         } else {
   20738           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   20739           0 :                                 return -1;
   20740             :                         }
   20741           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   20742           0 :                         if (unicode != NULL) {
   20743           0 :                                 Py_DECREF(unicode);
   20744             :                         }
   20745           0 :                         if (talloc_str == NULL) {
   20746           0 :                                 PyErr_NoMemory();
   20747           0 :                                 return -1;
   20748             :                         }
   20749           0 :                         object->pvReserved4 = talloc_str;
   20750             :                 }
   20751             :         }
   20752           0 :         return 0;
   20753             : }
   20754             : 
   20755           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_pvReserved5(PyObject *obj, void *closure)
   20756             : {
   20757           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   20758           0 :         PyObject *py_pvReserved5;
   20759           0 :         if (object->pvReserved5 == NULL) {
   20760           0 :                 Py_RETURN_NONE;
   20761             :         }
   20762           0 :         if (object->pvReserved5 == NULL) {
   20763           0 :                 py_pvReserved5 = Py_None;
   20764           0 :                 Py_INCREF(py_pvReserved5);
   20765             :         } else {
   20766           0 :                 if (object->pvReserved5 == NULL) {
   20767           0 :                         py_pvReserved5 = Py_None;
   20768           0 :                         Py_INCREF(py_pvReserved5);
   20769             :                 } else {
   20770           0 :                         py_pvReserved5 = PyUnicode_Decode(object->pvReserved5, strlen(object->pvReserved5), "utf-8", "ignore");
   20771             :                 }
   20772             :         }
   20773           0 :         return py_pvReserved5;
   20774             : }
   20775             : 
   20776           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_pvReserved5(PyObject *py_obj, PyObject *value, void *closure)
   20777             : {
   20778           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   20779           0 :         if (value == NULL) {
   20780           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pvReserved5");
   20781           0 :                 return -1;
   20782             :         }
   20783           0 :         if (value == Py_None) {
   20784           0 :                 object->pvReserved5 = NULL;
   20785             :         } else {
   20786           0 :                 object->pvReserved5 = NULL;
   20787             :                 {
   20788           0 :                         const char *test_str;
   20789           0 :                         const char *talloc_str;
   20790           0 :                         PyObject *unicode = NULL;
   20791           0 :                         if (PyUnicode_Check(value)) {
   20792           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   20793           0 :                                 if (unicode == NULL) {
   20794           0 :                                         return -1;
   20795             :                                 }
   20796           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   20797           0 :                         } else if (PyBytes_Check(value)) {
   20798           0 :                                 test_str = PyBytes_AS_STRING(value);
   20799             :                         } else {
   20800           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   20801           0 :                                 return -1;
   20802             :                         }
   20803           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   20804           0 :                         if (unicode != NULL) {
   20805           0 :                                 Py_DECREF(unicode);
   20806             :                         }
   20807           0 :                         if (talloc_str == NULL) {
   20808           0 :                                 PyErr_NoMemory();
   20809           0 :                                 return -1;
   20810             :                         }
   20811           0 :                         object->pvReserved5 = talloc_str;
   20812             :                 }
   20813             :         }
   20814           0 :         return 0;
   20815             : }
   20816             : 
   20817           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_pvReserved6(PyObject *obj, void *closure)
   20818             : {
   20819           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   20820           0 :         PyObject *py_pvReserved6;
   20821           0 :         if (object->pvReserved6 == NULL) {
   20822           0 :                 Py_RETURN_NONE;
   20823             :         }
   20824           0 :         if (object->pvReserved6 == NULL) {
   20825           0 :                 py_pvReserved6 = Py_None;
   20826           0 :                 Py_INCREF(py_pvReserved6);
   20827             :         } else {
   20828           0 :                 if (object->pvReserved6 == NULL) {
   20829           0 :                         py_pvReserved6 = Py_None;
   20830           0 :                         Py_INCREF(py_pvReserved6);
   20831             :                 } else {
   20832           0 :                         py_pvReserved6 = PyUnicode_Decode(object->pvReserved6, strlen(object->pvReserved6), "utf-8", "ignore");
   20833             :                 }
   20834             :         }
   20835           0 :         return py_pvReserved6;
   20836             : }
   20837             : 
   20838           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_pvReserved6(PyObject *py_obj, PyObject *value, void *closure)
   20839             : {
   20840           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   20841           0 :         if (value == NULL) {
   20842           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pvReserved6");
   20843           0 :                 return -1;
   20844             :         }
   20845           0 :         if (value == Py_None) {
   20846           0 :                 object->pvReserved6 = NULL;
   20847             :         } else {
   20848           0 :                 object->pvReserved6 = NULL;
   20849             :                 {
   20850           0 :                         const char *test_str;
   20851           0 :                         const char *talloc_str;
   20852           0 :                         PyObject *unicode = NULL;
   20853           0 :                         if (PyUnicode_Check(value)) {
   20854           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   20855           0 :                                 if (unicode == NULL) {
   20856           0 :                                         return -1;
   20857             :                                 }
   20858           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   20859           0 :                         } else if (PyBytes_Check(value)) {
   20860           0 :                                 test_str = PyBytes_AS_STRING(value);
   20861             :                         } else {
   20862           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   20863           0 :                                 return -1;
   20864             :                         }
   20865           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   20866           0 :                         if (unicode != NULL) {
   20867           0 :                                 Py_DECREF(unicode);
   20868             :                         }
   20869           0 :                         if (talloc_str == NULL) {
   20870           0 :                                 PyErr_NoMemory();
   20871           0 :                                 return -1;
   20872             :                         }
   20873           0 :                         object->pvReserved6 = talloc_str;
   20874             :                 }
   20875             :         }
   20876           0 :         return 0;
   20877             : }
   20878             : 
   20879           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_pvReserved7(PyObject *obj, void *closure)
   20880             : {
   20881           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   20882           0 :         PyObject *py_pvReserved7;
   20883           0 :         if (object->pvReserved7 == NULL) {
   20884           0 :                 Py_RETURN_NONE;
   20885             :         }
   20886           0 :         if (object->pvReserved7 == NULL) {
   20887           0 :                 py_pvReserved7 = Py_None;
   20888           0 :                 Py_INCREF(py_pvReserved7);
   20889             :         } else {
   20890           0 :                 if (object->pvReserved7 == NULL) {
   20891           0 :                         py_pvReserved7 = Py_None;
   20892           0 :                         Py_INCREF(py_pvReserved7);
   20893             :                 } else {
   20894           0 :                         py_pvReserved7 = PyUnicode_Decode(object->pvReserved7, strlen(object->pvReserved7), "utf-8", "ignore");
   20895             :                 }
   20896             :         }
   20897           0 :         return py_pvReserved7;
   20898             : }
   20899             : 
   20900           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_pvReserved7(PyObject *py_obj, PyObject *value, void *closure)
   20901             : {
   20902           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   20903           0 :         if (value == NULL) {
   20904           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pvReserved7");
   20905           0 :                 return -1;
   20906             :         }
   20907           0 :         if (value == Py_None) {
   20908           0 :                 object->pvReserved7 = NULL;
   20909             :         } else {
   20910           0 :                 object->pvReserved7 = NULL;
   20911             :                 {
   20912           0 :                         const char *test_str;
   20913           0 :                         const char *talloc_str;
   20914           0 :                         PyObject *unicode = NULL;
   20915           0 :                         if (PyUnicode_Check(value)) {
   20916           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   20917           0 :                                 if (unicode == NULL) {
   20918           0 :                                         return -1;
   20919             :                                 }
   20920           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   20921           0 :                         } else if (PyBytes_Check(value)) {
   20922           0 :                                 test_str = PyBytes_AS_STRING(value);
   20923             :                         } else {
   20924           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   20925           0 :                                 return -1;
   20926             :                         }
   20927           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   20928           0 :                         if (unicode != NULL) {
   20929           0 :                                 Py_DECREF(unicode);
   20930             :                         }
   20931           0 :                         if (talloc_str == NULL) {
   20932           0 :                                 PyErr_NoMemory();
   20933           0 :                                 return -1;
   20934             :                         }
   20935           0 :                         object->pvReserved7 = talloc_str;
   20936             :                 }
   20937             :         }
   20938           0 :         return 0;
   20939             : }
   20940             : 
   20941           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_pvReserved8(PyObject *obj, void *closure)
   20942             : {
   20943           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   20944           0 :         PyObject *py_pvReserved8;
   20945           0 :         if (object->pvReserved8 == NULL) {
   20946           0 :                 Py_RETURN_NONE;
   20947             :         }
   20948           0 :         if (object->pvReserved8 == NULL) {
   20949           0 :                 py_pvReserved8 = Py_None;
   20950           0 :                 Py_INCREF(py_pvReserved8);
   20951             :         } else {
   20952           0 :                 if (object->pvReserved8 == NULL) {
   20953           0 :                         py_pvReserved8 = Py_None;
   20954           0 :                         Py_INCREF(py_pvReserved8);
   20955             :                 } else {
   20956           0 :                         py_pvReserved8 = PyUnicode_Decode(object->pvReserved8, strlen(object->pvReserved8), "utf-8", "ignore");
   20957             :                 }
   20958             :         }
   20959           0 :         return py_pvReserved8;
   20960             : }
   20961             : 
   20962           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_pvReserved8(PyObject *py_obj, PyObject *value, void *closure)
   20963             : {
   20964           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   20965           0 :         if (value == NULL) {
   20966           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pvReserved8");
   20967           0 :                 return -1;
   20968             :         }
   20969           0 :         if (value == Py_None) {
   20970           0 :                 object->pvReserved8 = NULL;
   20971             :         } else {
   20972           0 :                 object->pvReserved8 = NULL;
   20973             :                 {
   20974           0 :                         const char *test_str;
   20975           0 :                         const char *talloc_str;
   20976           0 :                         PyObject *unicode = NULL;
   20977           0 :                         if (PyUnicode_Check(value)) {
   20978           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   20979           0 :                                 if (unicode == NULL) {
   20980           0 :                                         return -1;
   20981             :                                 }
   20982           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   20983           0 :                         } else if (PyBytes_Check(value)) {
   20984           0 :                                 test_str = PyBytes_AS_STRING(value);
   20985             :                         } else {
   20986           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   20987           0 :                                 return -1;
   20988             :                         }
   20989           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   20990           0 :                         if (unicode != NULL) {
   20991           0 :                                 Py_DECREF(unicode);
   20992             :                         }
   20993           0 :                         if (talloc_str == NULL) {
   20994           0 :                                 PyErr_NoMemory();
   20995           0 :                                 return -1;
   20996             :                         }
   20997           0 :                         object->pvReserved8 = talloc_str;
   20998             :                 }
   20999             :         }
   21000           0 :         return 0;
   21001             : }
   21002             : 
   21003           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_dwReserved1(PyObject *obj, void *closure)
   21004             : {
   21005           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   21006           0 :         PyObject *py_dwReserved1;
   21007           0 :         py_dwReserved1 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved1));
   21008           0 :         return py_dwReserved1;
   21009             : }
   21010             : 
   21011           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_dwReserved1(PyObject *py_obj, PyObject *value, void *closure)
   21012             : {
   21013           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   21014           0 :         if (value == NULL) {
   21015           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved1");
   21016           0 :                 return -1;
   21017             :         }
   21018             :         {
   21019           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved1));
   21020           0 :                 if (PyLong_Check(value)) {
   21021           0 :                         unsigned long long test_var;
   21022           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   21023           0 :                         if (PyErr_Occurred() != NULL) {
   21024           0 :                                 return -1;
   21025             :                         }
   21026           0 :                         if (test_var > uint_max) {
   21027           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   21028             :                                   PyLong_Type.tp_name, uint_max, test_var);
   21029           0 :                                 return -1;
   21030             :                         }
   21031           0 :                         object->dwReserved1 = test_var;
   21032             :                 } else {
   21033           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   21034             :                           PyLong_Type.tp_name);
   21035           0 :                         return -1;
   21036             :                 }
   21037             :         }
   21038           0 :         return 0;
   21039             : }
   21040             : 
   21041           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_dwReserved2(PyObject *obj, void *closure)
   21042             : {
   21043           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   21044           0 :         PyObject *py_dwReserved2;
   21045           0 :         py_dwReserved2 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved2));
   21046           0 :         return py_dwReserved2;
   21047             : }
   21048             : 
   21049           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_dwReserved2(PyObject *py_obj, PyObject *value, void *closure)
   21050             : {
   21051           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   21052           0 :         if (value == NULL) {
   21053           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved2");
   21054           0 :                 return -1;
   21055             :         }
   21056             :         {
   21057           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved2));
   21058           0 :                 if (PyLong_Check(value)) {
   21059           0 :                         unsigned long long test_var;
   21060           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   21061           0 :                         if (PyErr_Occurred() != NULL) {
   21062           0 :                                 return -1;
   21063             :                         }
   21064           0 :                         if (test_var > uint_max) {
   21065           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   21066             :                                   PyLong_Type.tp_name, uint_max, test_var);
   21067           0 :                                 return -1;
   21068             :                         }
   21069           0 :                         object->dwReserved2 = test_var;
   21070             :                 } else {
   21071           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   21072             :                           PyLong_Type.tp_name);
   21073           0 :                         return -1;
   21074             :                 }
   21075             :         }
   21076           0 :         return 0;
   21077             : }
   21078             : 
   21079           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_dwReserved3(PyObject *obj, void *closure)
   21080             : {
   21081           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   21082           0 :         PyObject *py_dwReserved3;
   21083           0 :         py_dwReserved3 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved3));
   21084           0 :         return py_dwReserved3;
   21085             : }
   21086             : 
   21087           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_dwReserved3(PyObject *py_obj, PyObject *value, void *closure)
   21088             : {
   21089           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   21090           0 :         if (value == NULL) {
   21091           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved3");
   21092           0 :                 return -1;
   21093             :         }
   21094             :         {
   21095           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved3));
   21096           0 :                 if (PyLong_Check(value)) {
   21097           0 :                         unsigned long long test_var;
   21098           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   21099           0 :                         if (PyErr_Occurred() != NULL) {
   21100           0 :                                 return -1;
   21101             :                         }
   21102           0 :                         if (test_var > uint_max) {
   21103           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   21104             :                                   PyLong_Type.tp_name, uint_max, test_var);
   21105           0 :                                 return -1;
   21106             :                         }
   21107           0 :                         object->dwReserved3 = test_var;
   21108             :                 } else {
   21109           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   21110             :                           PyLong_Type.tp_name);
   21111           0 :                         return -1;
   21112             :                 }
   21113             :         }
   21114           0 :         return 0;
   21115             : }
   21116             : 
   21117           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_dwReserved4(PyObject *obj, void *closure)
   21118             : {
   21119           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   21120           0 :         PyObject *py_dwReserved4;
   21121           0 :         py_dwReserved4 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved4));
   21122           0 :         return py_dwReserved4;
   21123             : }
   21124             : 
   21125           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_dwReserved4(PyObject *py_obj, PyObject *value, void *closure)
   21126             : {
   21127           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   21128           0 :         if (value == NULL) {
   21129           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved4");
   21130           0 :                 return -1;
   21131             :         }
   21132             :         {
   21133           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved4));
   21134           0 :                 if (PyLong_Check(value)) {
   21135           0 :                         unsigned long long test_var;
   21136           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   21137           0 :                         if (PyErr_Occurred() != NULL) {
   21138           0 :                                 return -1;
   21139             :                         }
   21140           0 :                         if (test_var > uint_max) {
   21141           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   21142             :                                   PyLong_Type.tp_name, uint_max, test_var);
   21143           0 :                                 return -1;
   21144             :                         }
   21145           0 :                         object->dwReserved4 = test_var;
   21146             :                 } else {
   21147           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   21148             :                           PyLong_Type.tp_name);
   21149           0 :                         return -1;
   21150             :                 }
   21151             :         }
   21152           0 :         return 0;
   21153             : }
   21154             : 
   21155           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_dwReserved5(PyObject *obj, void *closure)
   21156             : {
   21157           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   21158           0 :         PyObject *py_dwReserved5;
   21159           0 :         py_dwReserved5 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved5));
   21160           0 :         return py_dwReserved5;
   21161             : }
   21162             : 
   21163           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_dwReserved5(PyObject *py_obj, PyObject *value, void *closure)
   21164             : {
   21165           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   21166           0 :         if (value == NULL) {
   21167           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved5");
   21168           0 :                 return -1;
   21169             :         }
   21170             :         {
   21171           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved5));
   21172           0 :                 if (PyLong_Check(value)) {
   21173           0 :                         unsigned long long test_var;
   21174           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   21175           0 :                         if (PyErr_Occurred() != NULL) {
   21176           0 :                                 return -1;
   21177             :                         }
   21178           0 :                         if (test_var > uint_max) {
   21179           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   21180             :                                   PyLong_Type.tp_name, uint_max, test_var);
   21181           0 :                                 return -1;
   21182             :                         }
   21183           0 :                         object->dwReserved5 = test_var;
   21184             :                 } else {
   21185           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   21186             :                           PyLong_Type.tp_name);
   21187           0 :                         return -1;
   21188             :                 }
   21189             :         }
   21190           0 :         return 0;
   21191             : }
   21192             : 
   21193           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_dwReserved6(PyObject *obj, void *closure)
   21194             : {
   21195           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   21196           0 :         PyObject *py_dwReserved6;
   21197           0 :         py_dwReserved6 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved6));
   21198           0 :         return py_dwReserved6;
   21199             : }
   21200             : 
   21201           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_dwReserved6(PyObject *py_obj, PyObject *value, void *closure)
   21202             : {
   21203           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   21204           0 :         if (value == NULL) {
   21205           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved6");
   21206           0 :                 return -1;
   21207             :         }
   21208             :         {
   21209           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved6));
   21210           0 :                 if (PyLong_Check(value)) {
   21211           0 :                         unsigned long long test_var;
   21212           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   21213           0 :                         if (PyErr_Occurred() != NULL) {
   21214           0 :                                 return -1;
   21215             :                         }
   21216           0 :                         if (test_var > uint_max) {
   21217           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   21218             :                                   PyLong_Type.tp_name, uint_max, test_var);
   21219           0 :                                 return -1;
   21220             :                         }
   21221           0 :                         object->dwReserved6 = test_var;
   21222             :                 } else {
   21223           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   21224             :                           PyLong_Type.tp_name);
   21225           0 :                         return -1;
   21226             :                 }
   21227             :         }
   21228           0 :         return 0;
   21229             : }
   21230             : 
   21231           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_dwReserved7(PyObject *obj, void *closure)
   21232             : {
   21233           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   21234           0 :         PyObject *py_dwReserved7;
   21235           0 :         py_dwReserved7 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved7));
   21236           0 :         return py_dwReserved7;
   21237             : }
   21238             : 
   21239           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_dwReserved7(PyObject *py_obj, PyObject *value, void *closure)
   21240             : {
   21241           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   21242           0 :         if (value == NULL) {
   21243           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved7");
   21244           0 :                 return -1;
   21245             :         }
   21246             :         {
   21247           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved7));
   21248           0 :                 if (PyLong_Check(value)) {
   21249           0 :                         unsigned long long test_var;
   21250           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   21251           0 :                         if (PyErr_Occurred() != NULL) {
   21252           0 :                                 return -1;
   21253             :                         }
   21254           0 :                         if (test_var > uint_max) {
   21255           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   21256             :                                   PyLong_Type.tp_name, uint_max, test_var);
   21257           0 :                                 return -1;
   21258             :                         }
   21259           0 :                         object->dwReserved7 = test_var;
   21260             :                 } else {
   21261           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   21262             :                           PyLong_Type.tp_name);
   21263           0 :                         return -1;
   21264             :                 }
   21265             :         }
   21266           0 :         return 0;
   21267             : }
   21268             : 
   21269           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_dwReserved8(PyObject *obj, void *closure)
   21270             : {
   21271           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(obj);
   21272           0 :         PyObject *py_dwReserved8;
   21273           0 :         py_dwReserved8 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved8));
   21274           0 :         return py_dwReserved8;
   21275             : }
   21276             : 
   21277           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_dwReserved8(PyObject *py_obj, PyObject *value, void *closure)
   21278             : {
   21279           0 :         struct DNS_RPC_ZONE_CREATE_INFO_W2K *object = pytalloc_get_ptr(py_obj);
   21280           0 :         if (value == NULL) {
   21281           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved8");
   21282           0 :                 return -1;
   21283             :         }
   21284             :         {
   21285           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved8));
   21286           0 :                 if (PyLong_Check(value)) {
   21287           0 :                         unsigned long long test_var;
   21288           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   21289           0 :                         if (PyErr_Occurred() != NULL) {
   21290           0 :                                 return -1;
   21291             :                         }
   21292           0 :                         if (test_var > uint_max) {
   21293           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   21294             :                                   PyLong_Type.tp_name, uint_max, test_var);
   21295           0 :                                 return -1;
   21296             :                         }
   21297           0 :                         object->dwReserved8 = test_var;
   21298             :                 } else {
   21299           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   21300             :                           PyLong_Type.tp_name);
   21301           0 :                         return -1;
   21302             :                 }
   21303             :         }
   21304           0 :         return 0;
   21305             : }
   21306             : 
   21307             : static PyGetSetDef py_DNS_RPC_ZONE_CREATE_INFO_W2K_getsetters[] = {
   21308             :         {
   21309             :                 .name = discard_const_p(char, "pszZoneName"),
   21310             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_pszZoneName,
   21311             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_pszZoneName,
   21312             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   21313             :         },
   21314             :         {
   21315             :                 .name = discard_const_p(char, "dwZoneType"),
   21316             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_dwZoneType,
   21317             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_dwZoneType,
   21318             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   21319             :         },
   21320             :         {
   21321             :                 .name = discard_const_p(char, "fAllowUpdate"),
   21322             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_fAllowUpdate,
   21323             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_fAllowUpdate,
   21324             :                 .doc = discard_const_p(char, "PIDL-generated element of base type dns_zone_update")
   21325             :         },
   21326             :         {
   21327             :                 .name = discard_const_p(char, "fAging"),
   21328             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_fAging,
   21329             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_fAging,
   21330             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   21331             :         },
   21332             :         {
   21333             :                 .name = discard_const_p(char, "dwFlags"),
   21334             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_dwFlags,
   21335             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_dwFlags,
   21336             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   21337             :         },
   21338             :         {
   21339             :                 .name = discard_const_p(char, "pszDataFile"),
   21340             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_pszDataFile,
   21341             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_pszDataFile,
   21342             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   21343             :         },
   21344             :         {
   21345             :                 .name = discard_const_p(char, "fDsIntegrated"),
   21346             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_fDsIntegrated,
   21347             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_fDsIntegrated,
   21348             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   21349             :         },
   21350             :         {
   21351             :                 .name = discard_const_p(char, "fLoadExisting"),
   21352             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_fLoadExisting,
   21353             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_fLoadExisting,
   21354             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   21355             :         },
   21356             :         {
   21357             :                 .name = discard_const_p(char, "pszAdmin"),
   21358             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_pszAdmin,
   21359             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_pszAdmin,
   21360             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   21361             :         },
   21362             :         {
   21363             :                 .name = discard_const_p(char, "aipMasters"),
   21364             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_aipMasters,
   21365             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_aipMasters,
   21366             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
   21367             :         },
   21368             :         {
   21369             :                 .name = discard_const_p(char, "aipSecondaries"),
   21370             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_aipSecondaries,
   21371             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_aipSecondaries,
   21372             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
   21373             :         },
   21374             :         {
   21375             :                 .name = discard_const_p(char, "fSecureSecondaries"),
   21376             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_fSecureSecondaries,
   21377             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_fSecureSecondaries,
   21378             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ZONE_SECONDARY_SECURITY")
   21379             :         },
   21380             :         {
   21381             :                 .name = discard_const_p(char, "fNotifyLevel"),
   21382             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_fNotifyLevel,
   21383             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_fNotifyLevel,
   21384             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ZONE_NOTIFY_LEVEL")
   21385             :         },
   21386             :         {
   21387             :                 .name = discard_const_p(char, "pvReserved1"),
   21388             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_pvReserved1,
   21389             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_pvReserved1,
   21390             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   21391             :         },
   21392             :         {
   21393             :                 .name = discard_const_p(char, "pvReserved2"),
   21394             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_pvReserved2,
   21395             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_pvReserved2,
   21396             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   21397             :         },
   21398             :         {
   21399             :                 .name = discard_const_p(char, "pvReserved3"),
   21400             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_pvReserved3,
   21401             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_pvReserved3,
   21402             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   21403             :         },
   21404             :         {
   21405             :                 .name = discard_const_p(char, "pvReserved4"),
   21406             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_pvReserved4,
   21407             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_pvReserved4,
   21408             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   21409             :         },
   21410             :         {
   21411             :                 .name = discard_const_p(char, "pvReserved5"),
   21412             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_pvReserved5,
   21413             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_pvReserved5,
   21414             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   21415             :         },
   21416             :         {
   21417             :                 .name = discard_const_p(char, "pvReserved6"),
   21418             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_pvReserved6,
   21419             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_pvReserved6,
   21420             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   21421             :         },
   21422             :         {
   21423             :                 .name = discard_const_p(char, "pvReserved7"),
   21424             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_pvReserved7,
   21425             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_pvReserved7,
   21426             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   21427             :         },
   21428             :         {
   21429             :                 .name = discard_const_p(char, "pvReserved8"),
   21430             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_pvReserved8,
   21431             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_pvReserved8,
   21432             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   21433             :         },
   21434             :         {
   21435             :                 .name = discard_const_p(char, "dwReserved1"),
   21436             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_dwReserved1,
   21437             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_dwReserved1,
   21438             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   21439             :         },
   21440             :         {
   21441             :                 .name = discard_const_p(char, "dwReserved2"),
   21442             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_dwReserved2,
   21443             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_dwReserved2,
   21444             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   21445             :         },
   21446             :         {
   21447             :                 .name = discard_const_p(char, "dwReserved3"),
   21448             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_dwReserved3,
   21449             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_dwReserved3,
   21450             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   21451             :         },
   21452             :         {
   21453             :                 .name = discard_const_p(char, "dwReserved4"),
   21454             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_dwReserved4,
   21455             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_dwReserved4,
   21456             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   21457             :         },
   21458             :         {
   21459             :                 .name = discard_const_p(char, "dwReserved5"),
   21460             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_dwReserved5,
   21461             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_dwReserved5,
   21462             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   21463             :         },
   21464             :         {
   21465             :                 .name = discard_const_p(char, "dwReserved6"),
   21466             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_dwReserved6,
   21467             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_dwReserved6,
   21468             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   21469             :         },
   21470             :         {
   21471             :                 .name = discard_const_p(char, "dwReserved7"),
   21472             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_dwReserved7,
   21473             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_dwReserved7,
   21474             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   21475             :         },
   21476             :         {
   21477             :                 .name = discard_const_p(char, "dwReserved8"),
   21478             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_W2K_get_dwReserved8,
   21479             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_W2K_set_dwReserved8,
   21480             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   21481             :         },
   21482             :         { .name = NULL }
   21483             : };
   21484             : 
   21485           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_W2K_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   21486             : {
   21487           0 :         return pytalloc_new(struct DNS_RPC_ZONE_CREATE_INFO_W2K, type);
   21488             : }
   21489             : 
   21490             : 
   21491             : static PyTypeObject DNS_RPC_ZONE_CREATE_INFO_W2K_Type = {
   21492             :         PyVarObject_HEAD_INIT(NULL, 0)
   21493             :         .tp_name = "dnsserver.DNS_RPC_ZONE_CREATE_INFO_W2K",
   21494             :         .tp_getset = py_DNS_RPC_ZONE_CREATE_INFO_W2K_getsetters,
   21495             :         .tp_methods = NULL,
   21496             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   21497             :         .tp_new = py_DNS_RPC_ZONE_CREATE_INFO_W2K_new,
   21498             : };
   21499             : 
   21500             : 
   21501           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_dwRpcStructureVersion(PyObject *obj, void *closure)
   21502             : {
   21503           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   21504           0 :         PyObject *py_dwRpcStructureVersion;
   21505           0 :         py_dwRpcStructureVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcStructureVersion));
   21506           0 :         return py_dwRpcStructureVersion;
   21507             : }
   21508             : 
   21509           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_dwRpcStructureVersion(PyObject *py_obj, PyObject *value, void *closure)
   21510             : {
   21511           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   21512           0 :         if (value == NULL) {
   21513           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcStructureVersion");
   21514           0 :                 return -1;
   21515             :         }
   21516             :         {
   21517           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcStructureVersion));
   21518           0 :                 if (PyLong_Check(value)) {
   21519           0 :                         unsigned long long test_var;
   21520           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   21521           0 :                         if (PyErr_Occurred() != NULL) {
   21522           0 :                                 return -1;
   21523             :                         }
   21524           0 :                         if (test_var > uint_max) {
   21525           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   21526             :                                   PyLong_Type.tp_name, uint_max, test_var);
   21527           0 :                                 return -1;
   21528             :                         }
   21529           0 :                         object->dwRpcStructureVersion = test_var;
   21530             :                 } else {
   21531           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   21532             :                           PyLong_Type.tp_name);
   21533           0 :                         return -1;
   21534             :                 }
   21535             :         }
   21536           0 :         return 0;
   21537             : }
   21538             : 
   21539           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_dwReserved0(PyObject *obj, void *closure)
   21540             : {
   21541           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   21542           0 :         PyObject *py_dwReserved0;
   21543           0 :         py_dwReserved0 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved0));
   21544           0 :         return py_dwReserved0;
   21545             : }
   21546             : 
   21547           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_dwReserved0(PyObject *py_obj, PyObject *value, void *closure)
   21548             : {
   21549           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   21550           0 :         if (value == NULL) {
   21551           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved0");
   21552           0 :                 return -1;
   21553             :         }
   21554             :         {
   21555           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved0));
   21556           0 :                 if (PyLong_Check(value)) {
   21557           0 :                         unsigned long long test_var;
   21558           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   21559           0 :                         if (PyErr_Occurred() != NULL) {
   21560           0 :                                 return -1;
   21561             :                         }
   21562           0 :                         if (test_var > uint_max) {
   21563           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   21564             :                                   PyLong_Type.tp_name, uint_max, test_var);
   21565           0 :                                 return -1;
   21566             :                         }
   21567           0 :                         object->dwReserved0 = test_var;
   21568             :                 } else {
   21569           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   21570             :                           PyLong_Type.tp_name);
   21571           0 :                         return -1;
   21572             :                 }
   21573             :         }
   21574           0 :         return 0;
   21575             : }
   21576             : 
   21577           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_pszZoneName(PyObject *obj, void *closure)
   21578             : {
   21579           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   21580           0 :         PyObject *py_pszZoneName;
   21581           0 :         if (object->pszZoneName == NULL) {
   21582           0 :                 Py_RETURN_NONE;
   21583             :         }
   21584           0 :         if (object->pszZoneName == NULL) {
   21585           0 :                 py_pszZoneName = Py_None;
   21586           0 :                 Py_INCREF(py_pszZoneName);
   21587             :         } else {
   21588           0 :                 if (object->pszZoneName == NULL) {
   21589           0 :                         py_pszZoneName = Py_None;
   21590           0 :                         Py_INCREF(py_pszZoneName);
   21591             :                 } else {
   21592           0 :                         py_pszZoneName = PyUnicode_Decode(object->pszZoneName, strlen(object->pszZoneName), "utf-8", "ignore");
   21593             :                 }
   21594             :         }
   21595           0 :         return py_pszZoneName;
   21596             : }
   21597             : 
   21598           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_pszZoneName(PyObject *py_obj, PyObject *value, void *closure)
   21599             : {
   21600           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   21601           0 :         if (value == NULL) {
   21602           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszZoneName");
   21603           0 :                 return -1;
   21604             :         }
   21605           0 :         if (value == Py_None) {
   21606           0 :                 object->pszZoneName = NULL;
   21607             :         } else {
   21608           0 :                 object->pszZoneName = NULL;
   21609             :                 {
   21610           0 :                         const char *test_str;
   21611           0 :                         const char *talloc_str;
   21612           0 :                         PyObject *unicode = NULL;
   21613           0 :                         if (PyUnicode_Check(value)) {
   21614           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   21615           0 :                                 if (unicode == NULL) {
   21616           0 :                                         return -1;
   21617             :                                 }
   21618           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   21619           0 :                         } else if (PyBytes_Check(value)) {
   21620           0 :                                 test_str = PyBytes_AS_STRING(value);
   21621             :                         } else {
   21622           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   21623           0 :                                 return -1;
   21624             :                         }
   21625           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   21626           0 :                         if (unicode != NULL) {
   21627           0 :                                 Py_DECREF(unicode);
   21628             :                         }
   21629           0 :                         if (talloc_str == NULL) {
   21630           0 :                                 PyErr_NoMemory();
   21631           0 :                                 return -1;
   21632             :                         }
   21633           0 :                         object->pszZoneName = talloc_str;
   21634             :                 }
   21635             :         }
   21636           0 :         return 0;
   21637             : }
   21638             : 
   21639           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_dwZoneType(PyObject *obj, void *closure)
   21640             : {
   21641           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   21642           0 :         PyObject *py_dwZoneType;
   21643           0 :         py_dwZoneType = PyLong_FromUnsignedLongLong((uint32_t)(object->dwZoneType));
   21644           0 :         return py_dwZoneType;
   21645             : }
   21646             : 
   21647           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_dwZoneType(PyObject *py_obj, PyObject *value, void *closure)
   21648             : {
   21649           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   21650           0 :         if (value == NULL) {
   21651           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwZoneType");
   21652           0 :                 return -1;
   21653             :         }
   21654             :         {
   21655           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwZoneType));
   21656           0 :                 if (PyLong_Check(value)) {
   21657           0 :                         unsigned long long test_var;
   21658           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   21659           0 :                         if (PyErr_Occurred() != NULL) {
   21660           0 :                                 return -1;
   21661             :                         }
   21662           0 :                         if (test_var > uint_max) {
   21663           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   21664             :                                   PyLong_Type.tp_name, uint_max, test_var);
   21665           0 :                                 return -1;
   21666             :                         }
   21667           0 :                         object->dwZoneType = test_var;
   21668             :                 } else {
   21669           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   21670             :                           PyLong_Type.tp_name);
   21671           0 :                         return -1;
   21672             :                 }
   21673             :         }
   21674           0 :         return 0;
   21675             : }
   21676             : 
   21677           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_fAllowUpdate(PyObject *obj, void *closure)
   21678             : {
   21679           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   21680           0 :         PyObject *py_fAllowUpdate;
   21681           0 :         py_fAllowUpdate = PyLong_FromLong((uint16_t)(object->fAllowUpdate));
   21682           0 :         return py_fAllowUpdate;
   21683             : }
   21684             : 
   21685           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_fAllowUpdate(PyObject *py_obj, PyObject *value, void *closure)
   21686             : {
   21687           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   21688           0 :         if (value == NULL) {
   21689           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAllowUpdate");
   21690           0 :                 return -1;
   21691             :         }
   21692             :         {
   21693           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAllowUpdate));
   21694           0 :                 if (PyLong_Check(value)) {
   21695           0 :                         unsigned long long test_var;
   21696           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   21697           0 :                         if (PyErr_Occurred() != NULL) {
   21698           0 :                                 return -1;
   21699             :                         }
   21700           0 :                         if (test_var > uint_max) {
   21701           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   21702             :                                   PyLong_Type.tp_name, uint_max, test_var);
   21703           0 :                                 return -1;
   21704             :                         }
   21705           0 :                         object->fAllowUpdate = test_var;
   21706             :                 } else {
   21707           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   21708             :                           PyLong_Type.tp_name);
   21709           0 :                         return -1;
   21710             :                 }
   21711             :         }
   21712           0 :         return 0;
   21713             : }
   21714             : 
   21715           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_fAging(PyObject *obj, void *closure)
   21716             : {
   21717           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   21718           0 :         PyObject *py_fAging;
   21719           0 :         py_fAging = PyLong_FromUnsignedLongLong((uint32_t)(object->fAging));
   21720           0 :         return py_fAging;
   21721             : }
   21722             : 
   21723           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_fAging(PyObject *py_obj, PyObject *value, void *closure)
   21724             : {
   21725           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   21726           0 :         if (value == NULL) {
   21727           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAging");
   21728           0 :                 return -1;
   21729             :         }
   21730             :         {
   21731           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAging));
   21732           0 :                 if (PyLong_Check(value)) {
   21733           0 :                         unsigned long long test_var;
   21734           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   21735           0 :                         if (PyErr_Occurred() != NULL) {
   21736           0 :                                 return -1;
   21737             :                         }
   21738           0 :                         if (test_var > uint_max) {
   21739           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   21740             :                                   PyLong_Type.tp_name, uint_max, test_var);
   21741           0 :                                 return -1;
   21742             :                         }
   21743           0 :                         object->fAging = test_var;
   21744             :                 } else {
   21745           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   21746             :                           PyLong_Type.tp_name);
   21747           0 :                         return -1;
   21748             :                 }
   21749             :         }
   21750           0 :         return 0;
   21751             : }
   21752             : 
   21753           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_dwFlags(PyObject *obj, void *closure)
   21754             : {
   21755           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   21756           0 :         PyObject *py_dwFlags;
   21757           0 :         py_dwFlags = PyLong_FromUnsignedLongLong((uint32_t)(object->dwFlags));
   21758           0 :         return py_dwFlags;
   21759             : }
   21760             : 
   21761           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_dwFlags(PyObject *py_obj, PyObject *value, void *closure)
   21762             : {
   21763           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   21764           0 :         if (value == NULL) {
   21765           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwFlags");
   21766           0 :                 return -1;
   21767             :         }
   21768             :         {
   21769           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwFlags));
   21770           0 :                 if (PyLong_Check(value)) {
   21771           0 :                         unsigned long long test_var;
   21772           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   21773           0 :                         if (PyErr_Occurred() != NULL) {
   21774           0 :                                 return -1;
   21775             :                         }
   21776           0 :                         if (test_var > uint_max) {
   21777           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   21778             :                                   PyLong_Type.tp_name, uint_max, test_var);
   21779           0 :                                 return -1;
   21780             :                         }
   21781           0 :                         object->dwFlags = test_var;
   21782             :                 } else {
   21783           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   21784             :                           PyLong_Type.tp_name);
   21785           0 :                         return -1;
   21786             :                 }
   21787             :         }
   21788           0 :         return 0;
   21789             : }
   21790             : 
   21791           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_pszDataFile(PyObject *obj, void *closure)
   21792             : {
   21793           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   21794           0 :         PyObject *py_pszDataFile;
   21795           0 :         if (object->pszDataFile == NULL) {
   21796           0 :                 Py_RETURN_NONE;
   21797             :         }
   21798           0 :         if (object->pszDataFile == NULL) {
   21799           0 :                 py_pszDataFile = Py_None;
   21800           0 :                 Py_INCREF(py_pszDataFile);
   21801             :         } else {
   21802           0 :                 if (object->pszDataFile == NULL) {
   21803           0 :                         py_pszDataFile = Py_None;
   21804           0 :                         Py_INCREF(py_pszDataFile);
   21805             :                 } else {
   21806           0 :                         py_pszDataFile = PyUnicode_Decode(object->pszDataFile, strlen(object->pszDataFile), "utf-8", "ignore");
   21807             :                 }
   21808             :         }
   21809           0 :         return py_pszDataFile;
   21810             : }
   21811             : 
   21812           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_pszDataFile(PyObject *py_obj, PyObject *value, void *closure)
   21813             : {
   21814           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   21815           0 :         if (value == NULL) {
   21816           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszDataFile");
   21817           0 :                 return -1;
   21818             :         }
   21819           0 :         if (value == Py_None) {
   21820           0 :                 object->pszDataFile = NULL;
   21821             :         } else {
   21822           0 :                 object->pszDataFile = NULL;
   21823             :                 {
   21824           0 :                         const char *test_str;
   21825           0 :                         const char *talloc_str;
   21826           0 :                         PyObject *unicode = NULL;
   21827           0 :                         if (PyUnicode_Check(value)) {
   21828           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   21829           0 :                                 if (unicode == NULL) {
   21830           0 :                                         return -1;
   21831             :                                 }
   21832           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   21833           0 :                         } else if (PyBytes_Check(value)) {
   21834           0 :                                 test_str = PyBytes_AS_STRING(value);
   21835             :                         } else {
   21836           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   21837           0 :                                 return -1;
   21838             :                         }
   21839           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   21840           0 :                         if (unicode != NULL) {
   21841           0 :                                 Py_DECREF(unicode);
   21842             :                         }
   21843           0 :                         if (talloc_str == NULL) {
   21844           0 :                                 PyErr_NoMemory();
   21845           0 :                                 return -1;
   21846             :                         }
   21847           0 :                         object->pszDataFile = talloc_str;
   21848             :                 }
   21849             :         }
   21850           0 :         return 0;
   21851             : }
   21852             : 
   21853           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_fDsIntegrated(PyObject *obj, void *closure)
   21854             : {
   21855           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   21856           0 :         PyObject *py_fDsIntegrated;
   21857           0 :         py_fDsIntegrated = PyLong_FromUnsignedLongLong((uint32_t)(object->fDsIntegrated));
   21858           0 :         return py_fDsIntegrated;
   21859             : }
   21860             : 
   21861           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_fDsIntegrated(PyObject *py_obj, PyObject *value, void *closure)
   21862             : {
   21863           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   21864           0 :         if (value == NULL) {
   21865           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fDsIntegrated");
   21866           0 :                 return -1;
   21867             :         }
   21868             :         {
   21869           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fDsIntegrated));
   21870           0 :                 if (PyLong_Check(value)) {
   21871           0 :                         unsigned long long test_var;
   21872           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   21873           0 :                         if (PyErr_Occurred() != NULL) {
   21874           0 :                                 return -1;
   21875             :                         }
   21876           0 :                         if (test_var > uint_max) {
   21877           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   21878             :                                   PyLong_Type.tp_name, uint_max, test_var);
   21879           0 :                                 return -1;
   21880             :                         }
   21881           0 :                         object->fDsIntegrated = test_var;
   21882             :                 } else {
   21883           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   21884             :                           PyLong_Type.tp_name);
   21885           0 :                         return -1;
   21886             :                 }
   21887             :         }
   21888           0 :         return 0;
   21889             : }
   21890             : 
   21891           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_fLoadExisting(PyObject *obj, void *closure)
   21892             : {
   21893           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   21894           0 :         PyObject *py_fLoadExisting;
   21895           0 :         py_fLoadExisting = PyLong_FromUnsignedLongLong((uint32_t)(object->fLoadExisting));
   21896           0 :         return py_fLoadExisting;
   21897             : }
   21898             : 
   21899           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_fLoadExisting(PyObject *py_obj, PyObject *value, void *closure)
   21900             : {
   21901           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   21902           0 :         if (value == NULL) {
   21903           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fLoadExisting");
   21904           0 :                 return -1;
   21905             :         }
   21906             :         {
   21907           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fLoadExisting));
   21908           0 :                 if (PyLong_Check(value)) {
   21909           0 :                         unsigned long long test_var;
   21910           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   21911           0 :                         if (PyErr_Occurred() != NULL) {
   21912           0 :                                 return -1;
   21913             :                         }
   21914           0 :                         if (test_var > uint_max) {
   21915           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   21916             :                                   PyLong_Type.tp_name, uint_max, test_var);
   21917           0 :                                 return -1;
   21918             :                         }
   21919           0 :                         object->fLoadExisting = test_var;
   21920             :                 } else {
   21921           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   21922             :                           PyLong_Type.tp_name);
   21923           0 :                         return -1;
   21924             :                 }
   21925             :         }
   21926           0 :         return 0;
   21927             : }
   21928             : 
   21929           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_pszAdmin(PyObject *obj, void *closure)
   21930             : {
   21931           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   21932           0 :         PyObject *py_pszAdmin;
   21933           0 :         if (object->pszAdmin == NULL) {
   21934           0 :                 Py_RETURN_NONE;
   21935             :         }
   21936           0 :         if (object->pszAdmin == NULL) {
   21937           0 :                 py_pszAdmin = Py_None;
   21938           0 :                 Py_INCREF(py_pszAdmin);
   21939             :         } else {
   21940           0 :                 if (object->pszAdmin == NULL) {
   21941           0 :                         py_pszAdmin = Py_None;
   21942           0 :                         Py_INCREF(py_pszAdmin);
   21943             :                 } else {
   21944           0 :                         py_pszAdmin = PyUnicode_Decode(object->pszAdmin, strlen(object->pszAdmin), "utf-8", "ignore");
   21945             :                 }
   21946             :         }
   21947           0 :         return py_pszAdmin;
   21948             : }
   21949             : 
   21950           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_pszAdmin(PyObject *py_obj, PyObject *value, void *closure)
   21951             : {
   21952           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   21953           0 :         if (value == NULL) {
   21954           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszAdmin");
   21955           0 :                 return -1;
   21956             :         }
   21957           0 :         if (value == Py_None) {
   21958           0 :                 object->pszAdmin = NULL;
   21959             :         } else {
   21960           0 :                 object->pszAdmin = NULL;
   21961             :                 {
   21962           0 :                         const char *test_str;
   21963           0 :                         const char *talloc_str;
   21964           0 :                         PyObject *unicode = NULL;
   21965           0 :                         if (PyUnicode_Check(value)) {
   21966           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   21967           0 :                                 if (unicode == NULL) {
   21968           0 :                                         return -1;
   21969             :                                 }
   21970           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   21971           0 :                         } else if (PyBytes_Check(value)) {
   21972           0 :                                 test_str = PyBytes_AS_STRING(value);
   21973             :                         } else {
   21974           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   21975           0 :                                 return -1;
   21976             :                         }
   21977           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   21978           0 :                         if (unicode != NULL) {
   21979           0 :                                 Py_DECREF(unicode);
   21980             :                         }
   21981           0 :                         if (talloc_str == NULL) {
   21982           0 :                                 PyErr_NoMemory();
   21983           0 :                                 return -1;
   21984             :                         }
   21985           0 :                         object->pszAdmin = talloc_str;
   21986             :                 }
   21987             :         }
   21988           0 :         return 0;
   21989             : }
   21990             : 
   21991           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_aipMasters(PyObject *obj, void *closure)
   21992             : {
   21993           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   21994           0 :         PyObject *py_aipMasters;
   21995           0 :         if (object->aipMasters == NULL) {
   21996           0 :                 Py_RETURN_NONE;
   21997             :         }
   21998           0 :         if (object->aipMasters == NULL) {
   21999           0 :                 py_aipMasters = Py_None;
   22000           0 :                 Py_INCREF(py_aipMasters);
   22001             :         } else {
   22002           0 :                 py_aipMasters = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipMasters, object->aipMasters);
   22003             :         }
   22004           0 :         return py_aipMasters;
   22005             : }
   22006             : 
   22007           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_aipMasters(PyObject *py_obj, PyObject *value, void *closure)
   22008             : {
   22009           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   22010           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipMasters));
   22011           0 :         if (value == NULL) {
   22012           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipMasters");
   22013           0 :                 return -1;
   22014             :         }
   22015           0 :         if (value == Py_None) {
   22016           0 :                 object->aipMasters = NULL;
   22017             :         } else {
   22018           0 :                 object->aipMasters = NULL;
   22019           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
   22020           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   22021           0 :                         PyErr_NoMemory();
   22022           0 :                         return -1;
   22023             :                 }
   22024           0 :                 object->aipMasters = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
   22025             :         }
   22026           0 :         return 0;
   22027             : }
   22028             : 
   22029           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_aipSecondaries(PyObject *obj, void *closure)
   22030             : {
   22031           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   22032           0 :         PyObject *py_aipSecondaries;
   22033           0 :         if (object->aipSecondaries == NULL) {
   22034           0 :                 Py_RETURN_NONE;
   22035             :         }
   22036           0 :         if (object->aipSecondaries == NULL) {
   22037           0 :                 py_aipSecondaries = Py_None;
   22038           0 :                 Py_INCREF(py_aipSecondaries);
   22039             :         } else {
   22040           0 :                 py_aipSecondaries = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipSecondaries, object->aipSecondaries);
   22041             :         }
   22042           0 :         return py_aipSecondaries;
   22043             : }
   22044             : 
   22045           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_aipSecondaries(PyObject *py_obj, PyObject *value, void *closure)
   22046             : {
   22047           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   22048           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipSecondaries));
   22049           0 :         if (value == NULL) {
   22050           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipSecondaries");
   22051           0 :                 return -1;
   22052             :         }
   22053           0 :         if (value == Py_None) {
   22054           0 :                 object->aipSecondaries = NULL;
   22055             :         } else {
   22056           0 :                 object->aipSecondaries = NULL;
   22057           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
   22058           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   22059           0 :                         PyErr_NoMemory();
   22060           0 :                         return -1;
   22061             :                 }
   22062           0 :                 object->aipSecondaries = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
   22063             :         }
   22064           0 :         return 0;
   22065             : }
   22066             : 
   22067           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_fSecureSecondaries(PyObject *obj, void *closure)
   22068             : {
   22069           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   22070           0 :         PyObject *py_fSecureSecondaries;
   22071           0 :         py_fSecureSecondaries = PyLong_FromUnsignedLongLong((uint32_t)(object->fSecureSecondaries));
   22072           0 :         return py_fSecureSecondaries;
   22073             : }
   22074             : 
   22075           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_fSecureSecondaries(PyObject *py_obj, PyObject *value, void *closure)
   22076             : {
   22077           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   22078           0 :         if (value == NULL) {
   22079           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fSecureSecondaries");
   22080           0 :                 return -1;
   22081             :         }
   22082             :         {
   22083           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fSecureSecondaries));
   22084           0 :                 if (PyLong_Check(value)) {
   22085           0 :                         unsigned long long test_var;
   22086           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   22087           0 :                         if (PyErr_Occurred() != NULL) {
   22088           0 :                                 return -1;
   22089             :                         }
   22090           0 :                         if (test_var > uint_max) {
   22091           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   22092             :                                   PyLong_Type.tp_name, uint_max, test_var);
   22093           0 :                                 return -1;
   22094             :                         }
   22095           0 :                         object->fSecureSecondaries = test_var;
   22096             :                 } else {
   22097           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   22098             :                           PyLong_Type.tp_name);
   22099           0 :                         return -1;
   22100             :                 }
   22101             :         }
   22102           0 :         return 0;
   22103             : }
   22104             : 
   22105           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_fNotifyLevel(PyObject *obj, void *closure)
   22106             : {
   22107           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   22108           0 :         PyObject *py_fNotifyLevel;
   22109           0 :         py_fNotifyLevel = PyLong_FromUnsignedLongLong((uint32_t)(object->fNotifyLevel));
   22110           0 :         return py_fNotifyLevel;
   22111             : }
   22112             : 
   22113           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_fNotifyLevel(PyObject *py_obj, PyObject *value, void *closure)
   22114             : {
   22115           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   22116           0 :         if (value == NULL) {
   22117           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fNotifyLevel");
   22118           0 :                 return -1;
   22119             :         }
   22120             :         {
   22121           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fNotifyLevel));
   22122           0 :                 if (PyLong_Check(value)) {
   22123           0 :                         unsigned long long test_var;
   22124           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   22125           0 :                         if (PyErr_Occurred() != NULL) {
   22126           0 :                                 return -1;
   22127             :                         }
   22128           0 :                         if (test_var > uint_max) {
   22129           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   22130             :                                   PyLong_Type.tp_name, uint_max, test_var);
   22131           0 :                                 return -1;
   22132             :                         }
   22133           0 :                         object->fNotifyLevel = test_var;
   22134             :                 } else {
   22135           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   22136             :                           PyLong_Type.tp_name);
   22137           0 :                         return -1;
   22138             :                 }
   22139             :         }
   22140           0 :         return 0;
   22141             : }
   22142             : 
   22143           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_dwTimeout(PyObject *obj, void *closure)
   22144             : {
   22145           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   22146           0 :         PyObject *py_dwTimeout;
   22147           0 :         py_dwTimeout = PyLong_FromUnsignedLongLong((uint32_t)(object->dwTimeout));
   22148           0 :         return py_dwTimeout;
   22149             : }
   22150             : 
   22151           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_dwTimeout(PyObject *py_obj, PyObject *value, void *closure)
   22152             : {
   22153           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   22154           0 :         if (value == NULL) {
   22155           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwTimeout");
   22156           0 :                 return -1;
   22157             :         }
   22158             :         {
   22159           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwTimeout));
   22160           0 :                 if (PyLong_Check(value)) {
   22161           0 :                         unsigned long long test_var;
   22162           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   22163           0 :                         if (PyErr_Occurred() != NULL) {
   22164           0 :                                 return -1;
   22165             :                         }
   22166           0 :                         if (test_var > uint_max) {
   22167           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   22168             :                                   PyLong_Type.tp_name, uint_max, test_var);
   22169           0 :                                 return -1;
   22170             :                         }
   22171           0 :                         object->dwTimeout = test_var;
   22172             :                 } else {
   22173           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   22174             :                           PyLong_Type.tp_name);
   22175           0 :                         return -1;
   22176             :                 }
   22177             :         }
   22178           0 :         return 0;
   22179             : }
   22180             : 
   22181           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_fRecurseAfterForwarding(PyObject *obj, void *closure)
   22182             : {
   22183           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   22184           0 :         PyObject *py_fRecurseAfterForwarding;
   22185           0 :         py_fRecurseAfterForwarding = PyLong_FromUnsignedLongLong((uint32_t)(object->fRecurseAfterForwarding));
   22186           0 :         return py_fRecurseAfterForwarding;
   22187             : }
   22188             : 
   22189           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_fRecurseAfterForwarding(PyObject *py_obj, PyObject *value, void *closure)
   22190             : {
   22191           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   22192           0 :         if (value == NULL) {
   22193           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fRecurseAfterForwarding");
   22194           0 :                 return -1;
   22195             :         }
   22196             :         {
   22197           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fRecurseAfterForwarding));
   22198           0 :                 if (PyLong_Check(value)) {
   22199           0 :                         unsigned long long test_var;
   22200           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   22201           0 :                         if (PyErr_Occurred() != NULL) {
   22202           0 :                                 return -1;
   22203             :                         }
   22204           0 :                         if (test_var > uint_max) {
   22205           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   22206             :                                   PyLong_Type.tp_name, uint_max, test_var);
   22207           0 :                                 return -1;
   22208             :                         }
   22209           0 :                         object->fRecurseAfterForwarding = test_var;
   22210             :                 } else {
   22211           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   22212             :                           PyLong_Type.tp_name);
   22213           0 :                         return -1;
   22214             :                 }
   22215             :         }
   22216           0 :         return 0;
   22217             : }
   22218             : 
   22219           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_dwDpFlags(PyObject *obj, void *closure)
   22220             : {
   22221           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   22222           0 :         PyObject *py_dwDpFlags;
   22223           0 :         py_dwDpFlags = PyLong_FromUnsignedLongLong((uint32_t)(object->dwDpFlags));
   22224           0 :         return py_dwDpFlags;
   22225             : }
   22226             : 
   22227           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_dwDpFlags(PyObject *py_obj, PyObject *value, void *closure)
   22228             : {
   22229           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   22230           0 :         if (value == NULL) {
   22231           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwDpFlags");
   22232           0 :                 return -1;
   22233             :         }
   22234             :         {
   22235           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwDpFlags));
   22236           0 :                 if (PyLong_Check(value)) {
   22237           0 :                         unsigned long long test_var;
   22238           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   22239           0 :                         if (PyErr_Occurred() != NULL) {
   22240           0 :                                 return -1;
   22241             :                         }
   22242           0 :                         if (test_var > uint_max) {
   22243           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   22244             :                                   PyLong_Type.tp_name, uint_max, test_var);
   22245           0 :                                 return -1;
   22246             :                         }
   22247           0 :                         object->dwDpFlags = test_var;
   22248             :                 } else {
   22249           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   22250             :                           PyLong_Type.tp_name);
   22251           0 :                         return -1;
   22252             :                 }
   22253             :         }
   22254           0 :         return 0;
   22255             : }
   22256             : 
   22257           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_pszDpFqdn(PyObject *obj, void *closure)
   22258             : {
   22259           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   22260           0 :         PyObject *py_pszDpFqdn;
   22261           0 :         if (object->pszDpFqdn == NULL) {
   22262           0 :                 Py_RETURN_NONE;
   22263             :         }
   22264           0 :         if (object->pszDpFqdn == NULL) {
   22265           0 :                 py_pszDpFqdn = Py_None;
   22266           0 :                 Py_INCREF(py_pszDpFqdn);
   22267             :         } else {
   22268           0 :                 if (object->pszDpFqdn == NULL) {
   22269           0 :                         py_pszDpFqdn = Py_None;
   22270           0 :                         Py_INCREF(py_pszDpFqdn);
   22271             :                 } else {
   22272           0 :                         py_pszDpFqdn = PyUnicode_Decode(object->pszDpFqdn, strlen(object->pszDpFqdn), "utf-8", "ignore");
   22273             :                 }
   22274             :         }
   22275           0 :         return py_pszDpFqdn;
   22276             : }
   22277             : 
   22278           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_pszDpFqdn(PyObject *py_obj, PyObject *value, void *closure)
   22279             : {
   22280           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   22281           0 :         if (value == NULL) {
   22282           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszDpFqdn");
   22283           0 :                 return -1;
   22284             :         }
   22285           0 :         if (value == Py_None) {
   22286           0 :                 object->pszDpFqdn = NULL;
   22287             :         } else {
   22288           0 :                 object->pszDpFqdn = NULL;
   22289             :                 {
   22290           0 :                         const char *test_str;
   22291           0 :                         const char *talloc_str;
   22292           0 :                         PyObject *unicode = NULL;
   22293           0 :                         if (PyUnicode_Check(value)) {
   22294           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   22295           0 :                                 if (unicode == NULL) {
   22296           0 :                                         return -1;
   22297             :                                 }
   22298           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   22299           0 :                         } else if (PyBytes_Check(value)) {
   22300           0 :                                 test_str = PyBytes_AS_STRING(value);
   22301             :                         } else {
   22302           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   22303           0 :                                 return -1;
   22304             :                         }
   22305           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   22306           0 :                         if (unicode != NULL) {
   22307           0 :                                 Py_DECREF(unicode);
   22308             :                         }
   22309           0 :                         if (talloc_str == NULL) {
   22310           0 :                                 PyErr_NoMemory();
   22311           0 :                                 return -1;
   22312             :                         }
   22313           0 :                         object->pszDpFqdn = talloc_str;
   22314             :                 }
   22315             :         }
   22316           0 :         return 0;
   22317             : }
   22318             : 
   22319           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_dwReserved(PyObject *obj, void *closure)
   22320             : {
   22321           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(obj);
   22322           0 :         PyObject *py_dwReserved;
   22323           0 :         py_dwReserved = PyList_New(32);
   22324           0 :         if (py_dwReserved == NULL) {
   22325           0 :                 return NULL;
   22326             :         }
   22327             :         {
   22328             :                 int dwReserved_cntr_0;
   22329           0 :                 for (dwReserved_cntr_0 = 0; dwReserved_cntr_0 < (32); dwReserved_cntr_0++) {
   22330           0 :                         PyObject *py_dwReserved_0;
   22331           0 :                         py_dwReserved_0 = PyLong_FromUnsignedLongLong((uint32_t)((object->dwReserved)[dwReserved_cntr_0]));
   22332           0 :                         PyList_SetItem(py_dwReserved, dwReserved_cntr_0, py_dwReserved_0);
   22333             :                 }
   22334             :         }
   22335           0 :         return py_dwReserved;
   22336             : }
   22337             : 
   22338           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_dwReserved(PyObject *py_obj, PyObject *value, void *closure)
   22339             : {
   22340           0 :         struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *object = pytalloc_get_ptr(py_obj);
   22341           0 :         if (value == NULL) {
   22342           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved");
   22343           0 :                 return -1;
   22344             :         }
   22345           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
   22346             :         {
   22347           0 :                 int dwReserved_cntr_0;
   22348           0 :                 if (ARRAY_SIZE(object->dwReserved) != PyList_GET_SIZE(value)) {
   22349           0 :                         PyErr_Format(PyExc_TypeError, "Expected list of type %s, length %zu, got %zd", Py_TYPE(value)->tp_name, ARRAY_SIZE(object->dwReserved),  PyList_GET_SIZE(value));
   22350           0 :                         return -1;
   22351             :                 }
   22352           0 :                 for (dwReserved_cntr_0 = 0; dwReserved_cntr_0 < PyList_GET_SIZE(value); dwReserved_cntr_0++) {
   22353           0 :                         if (PyList_GET_ITEM(value, dwReserved_cntr_0) == NULL) {
   22354           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->dwReserved)[dwReserved_cntr_0]");
   22355           0 :                                 return -1;
   22356             :                         }
   22357             :                         {
   22358           0 :                                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof((object->dwReserved)[dwReserved_cntr_0]));
   22359           0 :                                 if (PyLong_Check(PyList_GET_ITEM(value, dwReserved_cntr_0))) {
   22360           0 :                                         unsigned long long test_var;
   22361           0 :                                         test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, dwReserved_cntr_0));
   22362           0 :                                         if (PyErr_Occurred() != NULL) {
   22363           0 :                                                 return -1;
   22364             :                                         }
   22365           0 :                                         if (test_var > uint_max) {
   22366           0 :                                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   22367             :                                                   PyLong_Type.tp_name, uint_max, test_var);
   22368           0 :                                                 return -1;
   22369             :                                         }
   22370           0 :                                         (object->dwReserved)[dwReserved_cntr_0] = test_var;
   22371             :                                 } else {
   22372           0 :                                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   22373             :                                           PyLong_Type.tp_name);
   22374           0 :                                         return -1;
   22375             :                                 }
   22376             :                         }
   22377             :                 }
   22378             :         }
   22379           0 :         return 0;
   22380             : }
   22381             : 
   22382             : static PyGetSetDef py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_getsetters[] = {
   22383             :         {
   22384             :                 .name = discard_const_p(char, "dwRpcStructureVersion"),
   22385             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_dwRpcStructureVersion,
   22386             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_dwRpcStructureVersion,
   22387             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   22388             :         },
   22389             :         {
   22390             :                 .name = discard_const_p(char, "dwReserved0"),
   22391             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_dwReserved0,
   22392             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_dwReserved0,
   22393             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   22394             :         },
   22395             :         {
   22396             :                 .name = discard_const_p(char, "pszZoneName"),
   22397             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_pszZoneName,
   22398             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_pszZoneName,
   22399             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   22400             :         },
   22401             :         {
   22402             :                 .name = discard_const_p(char, "dwZoneType"),
   22403             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_dwZoneType,
   22404             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_dwZoneType,
   22405             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   22406             :         },
   22407             :         {
   22408             :                 .name = discard_const_p(char, "fAllowUpdate"),
   22409             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_fAllowUpdate,
   22410             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_fAllowUpdate,
   22411             :                 .doc = discard_const_p(char, "PIDL-generated element of base type dns_zone_update")
   22412             :         },
   22413             :         {
   22414             :                 .name = discard_const_p(char, "fAging"),
   22415             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_fAging,
   22416             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_fAging,
   22417             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   22418             :         },
   22419             :         {
   22420             :                 .name = discard_const_p(char, "dwFlags"),
   22421             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_dwFlags,
   22422             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_dwFlags,
   22423             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   22424             :         },
   22425             :         {
   22426             :                 .name = discard_const_p(char, "pszDataFile"),
   22427             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_pszDataFile,
   22428             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_pszDataFile,
   22429             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   22430             :         },
   22431             :         {
   22432             :                 .name = discard_const_p(char, "fDsIntegrated"),
   22433             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_fDsIntegrated,
   22434             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_fDsIntegrated,
   22435             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   22436             :         },
   22437             :         {
   22438             :                 .name = discard_const_p(char, "fLoadExisting"),
   22439             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_fLoadExisting,
   22440             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_fLoadExisting,
   22441             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   22442             :         },
   22443             :         {
   22444             :                 .name = discard_const_p(char, "pszAdmin"),
   22445             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_pszAdmin,
   22446             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_pszAdmin,
   22447             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   22448             :         },
   22449             :         {
   22450             :                 .name = discard_const_p(char, "aipMasters"),
   22451             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_aipMasters,
   22452             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_aipMasters,
   22453             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
   22454             :         },
   22455             :         {
   22456             :                 .name = discard_const_p(char, "aipSecondaries"),
   22457             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_aipSecondaries,
   22458             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_aipSecondaries,
   22459             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
   22460             :         },
   22461             :         {
   22462             :                 .name = discard_const_p(char, "fSecureSecondaries"),
   22463             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_fSecureSecondaries,
   22464             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_fSecureSecondaries,
   22465             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ZONE_SECONDARY_SECURITY")
   22466             :         },
   22467             :         {
   22468             :                 .name = discard_const_p(char, "fNotifyLevel"),
   22469             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_fNotifyLevel,
   22470             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_fNotifyLevel,
   22471             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ZONE_NOTIFY_LEVEL")
   22472             :         },
   22473             :         {
   22474             :                 .name = discard_const_p(char, "dwTimeout"),
   22475             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_dwTimeout,
   22476             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_dwTimeout,
   22477             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   22478             :         },
   22479             :         {
   22480             :                 .name = discard_const_p(char, "fRecurseAfterForwarding"),
   22481             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_fRecurseAfterForwarding,
   22482             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_fRecurseAfterForwarding,
   22483             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   22484             :         },
   22485             :         {
   22486             :                 .name = discard_const_p(char, "dwDpFlags"),
   22487             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_dwDpFlags,
   22488             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_dwDpFlags,
   22489             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   22490             :         },
   22491             :         {
   22492             :                 .name = discard_const_p(char, "pszDpFqdn"),
   22493             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_pszDpFqdn,
   22494             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_pszDpFqdn,
   22495             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   22496             :         },
   22497             :         {
   22498             :                 .name = discard_const_p(char, "dwReserved"),
   22499             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_get_dwReserved,
   22500             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_set_dwReserved,
   22501             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   22502             :         },
   22503             :         { .name = NULL }
   22504             : };
   22505             : 
   22506           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   22507             : {
   22508           0 :         return pytalloc_new(struct DNS_RPC_ZONE_CREATE_INFO_DOTNET, type);
   22509             : }
   22510             : 
   22511             : 
   22512             : static PyTypeObject DNS_RPC_ZONE_CREATE_INFO_DOTNET_Type = {
   22513             :         PyVarObject_HEAD_INIT(NULL, 0)
   22514             :         .tp_name = "dnsserver.DNS_RPC_ZONE_CREATE_INFO_DOTNET",
   22515             :         .tp_getset = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_getsetters,
   22516             :         .tp_methods = NULL,
   22517             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   22518             :         .tp_new = py_DNS_RPC_ZONE_CREATE_INFO_DOTNET_new,
   22519             : };
   22520             : 
   22521             : 
   22522           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_dwRpcStructureVersion(PyObject *obj, void *closure)
   22523             : {
   22524           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   22525           0 :         PyObject *py_dwRpcStructureVersion;
   22526           0 :         py_dwRpcStructureVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcStructureVersion));
   22527           0 :         return py_dwRpcStructureVersion;
   22528             : }
   22529             : 
   22530           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_dwRpcStructureVersion(PyObject *py_obj, PyObject *value, void *closure)
   22531             : {
   22532           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   22533           0 :         if (value == NULL) {
   22534           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcStructureVersion");
   22535           0 :                 return -1;
   22536             :         }
   22537             :         {
   22538           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcStructureVersion));
   22539           0 :                 if (PyLong_Check(value)) {
   22540           0 :                         unsigned long long test_var;
   22541           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   22542           0 :                         if (PyErr_Occurred() != NULL) {
   22543           0 :                                 return -1;
   22544             :                         }
   22545           0 :                         if (test_var > uint_max) {
   22546           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   22547             :                                   PyLong_Type.tp_name, uint_max, test_var);
   22548           0 :                                 return -1;
   22549             :                         }
   22550           0 :                         object->dwRpcStructureVersion = test_var;
   22551             :                 } else {
   22552           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   22553             :                           PyLong_Type.tp_name);
   22554           0 :                         return -1;
   22555             :                 }
   22556             :         }
   22557           0 :         return 0;
   22558             : }
   22559             : 
   22560           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_dwReserved0(PyObject *obj, void *closure)
   22561             : {
   22562           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   22563           0 :         PyObject *py_dwReserved0;
   22564           0 :         py_dwReserved0 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved0));
   22565           0 :         return py_dwReserved0;
   22566             : }
   22567             : 
   22568           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_dwReserved0(PyObject *py_obj, PyObject *value, void *closure)
   22569             : {
   22570           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   22571           0 :         if (value == NULL) {
   22572           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved0");
   22573           0 :                 return -1;
   22574             :         }
   22575             :         {
   22576           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved0));
   22577           0 :                 if (PyLong_Check(value)) {
   22578           0 :                         unsigned long long test_var;
   22579           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   22580           0 :                         if (PyErr_Occurred() != NULL) {
   22581           0 :                                 return -1;
   22582             :                         }
   22583           0 :                         if (test_var > uint_max) {
   22584           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   22585             :                                   PyLong_Type.tp_name, uint_max, test_var);
   22586           0 :                                 return -1;
   22587             :                         }
   22588           0 :                         object->dwReserved0 = test_var;
   22589             :                 } else {
   22590           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   22591             :                           PyLong_Type.tp_name);
   22592           0 :                         return -1;
   22593             :                 }
   22594             :         }
   22595           0 :         return 0;
   22596             : }
   22597             : 
   22598           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_pszZoneName(PyObject *obj, void *closure)
   22599             : {
   22600           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   22601           0 :         PyObject *py_pszZoneName;
   22602           0 :         if (object->pszZoneName == NULL) {
   22603           0 :                 Py_RETURN_NONE;
   22604             :         }
   22605           0 :         if (object->pszZoneName == NULL) {
   22606           0 :                 py_pszZoneName = Py_None;
   22607           0 :                 Py_INCREF(py_pszZoneName);
   22608             :         } else {
   22609           0 :                 if (object->pszZoneName == NULL) {
   22610           0 :                         py_pszZoneName = Py_None;
   22611           0 :                         Py_INCREF(py_pszZoneName);
   22612             :                 } else {
   22613           0 :                         py_pszZoneName = PyUnicode_Decode(object->pszZoneName, strlen(object->pszZoneName), "utf-8", "ignore");
   22614             :                 }
   22615             :         }
   22616           0 :         return py_pszZoneName;
   22617             : }
   22618             : 
   22619         427 : static int py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_pszZoneName(PyObject *py_obj, PyObject *value, void *closure)
   22620             : {
   22621         427 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   22622         427 :         if (value == NULL) {
   22623           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszZoneName");
   22624           0 :                 return -1;
   22625             :         }
   22626         427 :         if (value == Py_None) {
   22627           0 :                 object->pszZoneName = NULL;
   22628             :         } else {
   22629         427 :                 object->pszZoneName = NULL;
   22630             :                 {
   22631           0 :                         const char *test_str;
   22632           0 :                         const char *talloc_str;
   22633         427 :                         PyObject *unicode = NULL;
   22634         427 :                         if (PyUnicode_Check(value)) {
   22635         427 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   22636         427 :                                 if (unicode == NULL) {
   22637           0 :                                         return -1;
   22638             :                                 }
   22639         427 :                                 test_str = PyBytes_AS_STRING(unicode);
   22640           0 :                         } else if (PyBytes_Check(value)) {
   22641           0 :                                 test_str = PyBytes_AS_STRING(value);
   22642             :                         } else {
   22643           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   22644           0 :                                 return -1;
   22645             :                         }
   22646         427 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   22647         427 :                         if (unicode != NULL) {
   22648         257 :                                 Py_DECREF(unicode);
   22649             :                         }
   22650         427 :                         if (talloc_str == NULL) {
   22651           0 :                                 PyErr_NoMemory();
   22652           0 :                                 return -1;
   22653             :                         }
   22654         427 :                         object->pszZoneName = talloc_str;
   22655             :                 }
   22656             :         }
   22657         427 :         return 0;
   22658             : }
   22659             : 
   22660           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_dwZoneType(PyObject *obj, void *closure)
   22661             : {
   22662           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   22663           0 :         PyObject *py_dwZoneType;
   22664           0 :         py_dwZoneType = PyLong_FromUnsignedLongLong((uint32_t)(object->dwZoneType));
   22665           0 :         return py_dwZoneType;
   22666             : }
   22667             : 
   22668         427 : static int py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_dwZoneType(PyObject *py_obj, PyObject *value, void *closure)
   22669             : {
   22670         427 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   22671         427 :         if (value == NULL) {
   22672           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwZoneType");
   22673           0 :                 return -1;
   22674             :         }
   22675             :         {
   22676         427 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwZoneType));
   22677         427 :                 if (PyLong_Check(value)) {
   22678           0 :                         unsigned long long test_var;
   22679         427 :                         test_var = PyLong_AsUnsignedLongLong(value);
   22680         427 :                         if (PyErr_Occurred() != NULL) {
   22681           0 :                                 return -1;
   22682             :                         }
   22683         427 :                         if (test_var > uint_max) {
   22684           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   22685             :                                   PyLong_Type.tp_name, uint_max, test_var);
   22686           0 :                                 return -1;
   22687             :                         }
   22688         427 :                         object->dwZoneType = test_var;
   22689             :                 } else {
   22690           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   22691             :                           PyLong_Type.tp_name);
   22692           0 :                         return -1;
   22693             :                 }
   22694             :         }
   22695         427 :         return 0;
   22696             : }
   22697             : 
   22698           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_fAllowUpdate(PyObject *obj, void *closure)
   22699             : {
   22700           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   22701           0 :         PyObject *py_fAllowUpdate;
   22702           0 :         py_fAllowUpdate = PyLong_FromLong((uint16_t)(object->fAllowUpdate));
   22703           0 :         return py_fAllowUpdate;
   22704             : }
   22705             : 
   22706         330 : static int py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_fAllowUpdate(PyObject *py_obj, PyObject *value, void *closure)
   22707             : {
   22708         330 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   22709         330 :         if (value == NULL) {
   22710           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAllowUpdate");
   22711           0 :                 return -1;
   22712             :         }
   22713             :         {
   22714         330 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAllowUpdate));
   22715         330 :                 if (PyLong_Check(value)) {
   22716           0 :                         unsigned long long test_var;
   22717         330 :                         test_var = PyLong_AsUnsignedLongLong(value);
   22718         330 :                         if (PyErr_Occurred() != NULL) {
   22719           0 :                                 return -1;
   22720             :                         }
   22721         330 :                         if (test_var > uint_max) {
   22722           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   22723             :                                   PyLong_Type.tp_name, uint_max, test_var);
   22724           0 :                                 return -1;
   22725             :                         }
   22726         330 :                         object->fAllowUpdate = test_var;
   22727             :                 } else {
   22728           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   22729             :                           PyLong_Type.tp_name);
   22730           0 :                         return -1;
   22731             :                 }
   22732             :         }
   22733         330 :         return 0;
   22734             : }
   22735             : 
   22736           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_fAging(PyObject *obj, void *closure)
   22737             : {
   22738           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   22739           0 :         PyObject *py_fAging;
   22740           0 :         py_fAging = PyLong_FromUnsignedLongLong((uint32_t)(object->fAging));
   22741           0 :         return py_fAging;
   22742             : }
   22743             : 
   22744         427 : static int py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_fAging(PyObject *py_obj, PyObject *value, void *closure)
   22745             : {
   22746         427 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   22747         427 :         if (value == NULL) {
   22748           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fAging");
   22749           0 :                 return -1;
   22750             :         }
   22751             :         {
   22752         427 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fAging));
   22753         427 :                 if (PyLong_Check(value)) {
   22754           0 :                         unsigned long long test_var;
   22755         427 :                         test_var = PyLong_AsUnsignedLongLong(value);
   22756         427 :                         if (PyErr_Occurred() != NULL) {
   22757           0 :                                 return -1;
   22758             :                         }
   22759         427 :                         if (test_var > uint_max) {
   22760           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   22761             :                                   PyLong_Type.tp_name, uint_max, test_var);
   22762           0 :                                 return -1;
   22763             :                         }
   22764         427 :                         object->fAging = test_var;
   22765             :                 } else {
   22766           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   22767             :                           PyLong_Type.tp_name);
   22768           0 :                         return -1;
   22769             :                 }
   22770             :         }
   22771         427 :         return 0;
   22772             : }
   22773             : 
   22774           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_dwFlags(PyObject *obj, void *closure)
   22775             : {
   22776           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   22777           0 :         PyObject *py_dwFlags;
   22778           0 :         py_dwFlags = PyLong_FromUnsignedLongLong((uint32_t)(object->dwFlags));
   22779           0 :         return py_dwFlags;
   22780             : }
   22781             : 
   22782           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_dwFlags(PyObject *py_obj, PyObject *value, void *closure)
   22783             : {
   22784           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   22785           0 :         if (value == NULL) {
   22786           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwFlags");
   22787           0 :                 return -1;
   22788             :         }
   22789             :         {
   22790           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwFlags));
   22791           0 :                 if (PyLong_Check(value)) {
   22792           0 :                         unsigned long long test_var;
   22793           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   22794           0 :                         if (PyErr_Occurred() != NULL) {
   22795           0 :                                 return -1;
   22796             :                         }
   22797           0 :                         if (test_var > uint_max) {
   22798           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   22799             :                                   PyLong_Type.tp_name, uint_max, test_var);
   22800           0 :                                 return -1;
   22801             :                         }
   22802           0 :                         object->dwFlags = test_var;
   22803             :                 } else {
   22804           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   22805             :                           PyLong_Type.tp_name);
   22806           0 :                         return -1;
   22807             :                 }
   22808             :         }
   22809           0 :         return 0;
   22810             : }
   22811             : 
   22812           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_pszDataFile(PyObject *obj, void *closure)
   22813             : {
   22814           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   22815           0 :         PyObject *py_pszDataFile;
   22816           0 :         if (object->pszDataFile == NULL) {
   22817           0 :                 Py_RETURN_NONE;
   22818             :         }
   22819           0 :         if (object->pszDataFile == NULL) {
   22820           0 :                 py_pszDataFile = Py_None;
   22821           0 :                 Py_INCREF(py_pszDataFile);
   22822             :         } else {
   22823           0 :                 if (object->pszDataFile == NULL) {
   22824           0 :                         py_pszDataFile = Py_None;
   22825           0 :                         Py_INCREF(py_pszDataFile);
   22826             :                 } else {
   22827           0 :                         py_pszDataFile = PyUnicode_Decode(object->pszDataFile, strlen(object->pszDataFile), "utf-8", "ignore");
   22828             :                 }
   22829             :         }
   22830           0 :         return py_pszDataFile;
   22831             : }
   22832             : 
   22833           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_pszDataFile(PyObject *py_obj, PyObject *value, void *closure)
   22834             : {
   22835           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   22836           0 :         if (value == NULL) {
   22837           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszDataFile");
   22838           0 :                 return -1;
   22839             :         }
   22840           0 :         if (value == Py_None) {
   22841           0 :                 object->pszDataFile = NULL;
   22842             :         } else {
   22843           0 :                 object->pszDataFile = NULL;
   22844             :                 {
   22845           0 :                         const char *test_str;
   22846           0 :                         const char *talloc_str;
   22847           0 :                         PyObject *unicode = NULL;
   22848           0 :                         if (PyUnicode_Check(value)) {
   22849           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   22850           0 :                                 if (unicode == NULL) {
   22851           0 :                                         return -1;
   22852             :                                 }
   22853           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   22854           0 :                         } else if (PyBytes_Check(value)) {
   22855           0 :                                 test_str = PyBytes_AS_STRING(value);
   22856             :                         } else {
   22857           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   22858           0 :                                 return -1;
   22859             :                         }
   22860           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   22861           0 :                         if (unicode != NULL) {
   22862           0 :                                 Py_DECREF(unicode);
   22863             :                         }
   22864           0 :                         if (talloc_str == NULL) {
   22865           0 :                                 PyErr_NoMemory();
   22866           0 :                                 return -1;
   22867             :                         }
   22868           0 :                         object->pszDataFile = talloc_str;
   22869             :                 }
   22870             :         }
   22871           0 :         return 0;
   22872             : }
   22873             : 
   22874           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_fDsIntegrated(PyObject *obj, void *closure)
   22875             : {
   22876           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   22877           0 :         PyObject *py_fDsIntegrated;
   22878           0 :         py_fDsIntegrated = PyLong_FromUnsignedLongLong((uint32_t)(object->fDsIntegrated));
   22879           0 :         return py_fDsIntegrated;
   22880             : }
   22881             : 
   22882         424 : static int py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_fDsIntegrated(PyObject *py_obj, PyObject *value, void *closure)
   22883             : {
   22884         424 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   22885         424 :         if (value == NULL) {
   22886           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fDsIntegrated");
   22887           0 :                 return -1;
   22888             :         }
   22889             :         {
   22890         424 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fDsIntegrated));
   22891         424 :                 if (PyLong_Check(value)) {
   22892           0 :                         unsigned long long test_var;
   22893         424 :                         test_var = PyLong_AsUnsignedLongLong(value);
   22894         424 :                         if (PyErr_Occurred() != NULL) {
   22895           0 :                                 return -1;
   22896             :                         }
   22897         424 :                         if (test_var > uint_max) {
   22898           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   22899             :                                   PyLong_Type.tp_name, uint_max, test_var);
   22900           0 :                                 return -1;
   22901             :                         }
   22902         424 :                         object->fDsIntegrated = test_var;
   22903             :                 } else {
   22904           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   22905             :                           PyLong_Type.tp_name);
   22906           0 :                         return -1;
   22907             :                 }
   22908             :         }
   22909         424 :         return 0;
   22910             : }
   22911             : 
   22912           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_fLoadExisting(PyObject *obj, void *closure)
   22913             : {
   22914           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   22915           0 :         PyObject *py_fLoadExisting;
   22916           0 :         py_fLoadExisting = PyLong_FromUnsignedLongLong((uint32_t)(object->fLoadExisting));
   22917           0 :         return py_fLoadExisting;
   22918             : }
   22919             : 
   22920         424 : static int py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_fLoadExisting(PyObject *py_obj, PyObject *value, void *closure)
   22921             : {
   22922         424 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   22923         424 :         if (value == NULL) {
   22924           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fLoadExisting");
   22925           0 :                 return -1;
   22926             :         }
   22927             :         {
   22928         424 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fLoadExisting));
   22929         424 :                 if (PyLong_Check(value)) {
   22930           0 :                         unsigned long long test_var;
   22931         424 :                         test_var = PyLong_AsUnsignedLongLong(value);
   22932         424 :                         if (PyErr_Occurred() != NULL) {
   22933           0 :                                 return -1;
   22934             :                         }
   22935         424 :                         if (test_var > uint_max) {
   22936           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   22937             :                                   PyLong_Type.tp_name, uint_max, test_var);
   22938           0 :                                 return -1;
   22939             :                         }
   22940         424 :                         object->fLoadExisting = test_var;
   22941             :                 } else {
   22942           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   22943             :                           PyLong_Type.tp_name);
   22944           0 :                         return -1;
   22945             :                 }
   22946             :         }
   22947         424 :         return 0;
   22948             : }
   22949             : 
   22950           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_pszAdmin(PyObject *obj, void *closure)
   22951             : {
   22952           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   22953           0 :         PyObject *py_pszAdmin;
   22954           0 :         if (object->pszAdmin == NULL) {
   22955           0 :                 Py_RETURN_NONE;
   22956             :         }
   22957           0 :         if (object->pszAdmin == NULL) {
   22958           0 :                 py_pszAdmin = Py_None;
   22959           0 :                 Py_INCREF(py_pszAdmin);
   22960             :         } else {
   22961           0 :                 if (object->pszAdmin == NULL) {
   22962           0 :                         py_pszAdmin = Py_None;
   22963           0 :                         Py_INCREF(py_pszAdmin);
   22964             :                 } else {
   22965           0 :                         py_pszAdmin = PyUnicode_Decode(object->pszAdmin, strlen(object->pszAdmin), "utf-8", "ignore");
   22966             :                 }
   22967             :         }
   22968           0 :         return py_pszAdmin;
   22969             : }
   22970             : 
   22971           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_pszAdmin(PyObject *py_obj, PyObject *value, void *closure)
   22972             : {
   22973           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   22974           0 :         if (value == NULL) {
   22975           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszAdmin");
   22976           0 :                 return -1;
   22977             :         }
   22978           0 :         if (value == Py_None) {
   22979           0 :                 object->pszAdmin = NULL;
   22980             :         } else {
   22981           0 :                 object->pszAdmin = NULL;
   22982             :                 {
   22983           0 :                         const char *test_str;
   22984           0 :                         const char *talloc_str;
   22985           0 :                         PyObject *unicode = NULL;
   22986           0 :                         if (PyUnicode_Check(value)) {
   22987           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   22988           0 :                                 if (unicode == NULL) {
   22989           0 :                                         return -1;
   22990             :                                 }
   22991           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   22992           0 :                         } else if (PyBytes_Check(value)) {
   22993           0 :                                 test_str = PyBytes_AS_STRING(value);
   22994             :                         } else {
   22995           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   22996           0 :                                 return -1;
   22997             :                         }
   22998           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   22999           0 :                         if (unicode != NULL) {
   23000           0 :                                 Py_DECREF(unicode);
   23001             :                         }
   23002           0 :                         if (talloc_str == NULL) {
   23003           0 :                                 PyErr_NoMemory();
   23004           0 :                                 return -1;
   23005             :                         }
   23006           0 :                         object->pszAdmin = talloc_str;
   23007             :                 }
   23008             :         }
   23009           0 :         return 0;
   23010             : }
   23011             : 
   23012           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_aipMasters(PyObject *obj, void *closure)
   23013             : {
   23014           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   23015           0 :         PyObject *py_aipMasters;
   23016           0 :         if (object->aipMasters == NULL) {
   23017           0 :                 Py_RETURN_NONE;
   23018             :         }
   23019           0 :         if (object->aipMasters == NULL) {
   23020           0 :                 py_aipMasters = Py_None;
   23021           0 :                 Py_INCREF(py_aipMasters);
   23022             :         } else {
   23023           0 :                 py_aipMasters = pytalloc_reference_ex(&DNS_ADDR_ARRAY_Type, object->aipMasters, object->aipMasters);
   23024             :         }
   23025           0 :         return py_aipMasters;
   23026             : }
   23027             : 
   23028           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_aipMasters(PyObject *py_obj, PyObject *value, void *closure)
   23029             : {
   23030           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   23031           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipMasters));
   23032           0 :         if (value == NULL) {
   23033           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipMasters");
   23034           0 :                 return -1;
   23035             :         }
   23036           0 :         if (value == Py_None) {
   23037           0 :                 object->aipMasters = NULL;
   23038             :         } else {
   23039           0 :                 object->aipMasters = NULL;
   23040           0 :                 PY_CHECK_TYPE(&DNS_ADDR_ARRAY_Type, value, return -1;);
   23041           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   23042           0 :                         PyErr_NoMemory();
   23043           0 :                         return -1;
   23044             :                 }
   23045           0 :                 object->aipMasters = (struct DNS_ADDR_ARRAY *)pytalloc_get_ptr(value);
   23046             :         }
   23047           0 :         return 0;
   23048             : }
   23049             : 
   23050           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_aipSecondaries(PyObject *obj, void *closure)
   23051             : {
   23052           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   23053           0 :         PyObject *py_aipSecondaries;
   23054           0 :         if (object->aipSecondaries == NULL) {
   23055           0 :                 Py_RETURN_NONE;
   23056             :         }
   23057           0 :         if (object->aipSecondaries == NULL) {
   23058           0 :                 py_aipSecondaries = Py_None;
   23059           0 :                 Py_INCREF(py_aipSecondaries);
   23060             :         } else {
   23061           0 :                 py_aipSecondaries = pytalloc_reference_ex(&DNS_ADDR_ARRAY_Type, object->aipSecondaries, object->aipSecondaries);
   23062             :         }
   23063           0 :         return py_aipSecondaries;
   23064             : }
   23065             : 
   23066           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_aipSecondaries(PyObject *py_obj, PyObject *value, void *closure)
   23067             : {
   23068           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   23069           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipSecondaries));
   23070           0 :         if (value == NULL) {
   23071           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipSecondaries");
   23072           0 :                 return -1;
   23073             :         }
   23074           0 :         if (value == Py_None) {
   23075           0 :                 object->aipSecondaries = NULL;
   23076             :         } else {
   23077           0 :                 object->aipSecondaries = NULL;
   23078           0 :                 PY_CHECK_TYPE(&DNS_ADDR_ARRAY_Type, value, return -1;);
   23079           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   23080           0 :                         PyErr_NoMemory();
   23081           0 :                         return -1;
   23082             :                 }
   23083           0 :                 object->aipSecondaries = (struct DNS_ADDR_ARRAY *)pytalloc_get_ptr(value);
   23084             :         }
   23085           0 :         return 0;
   23086             : }
   23087             : 
   23088           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_fSecureSecondaries(PyObject *obj, void *closure)
   23089             : {
   23090           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   23091           0 :         PyObject *py_fSecureSecondaries;
   23092           0 :         py_fSecureSecondaries = PyLong_FromUnsignedLongLong((uint32_t)(object->fSecureSecondaries));
   23093           0 :         return py_fSecureSecondaries;
   23094             : }
   23095             : 
   23096           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_fSecureSecondaries(PyObject *py_obj, PyObject *value, void *closure)
   23097             : {
   23098           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   23099           0 :         if (value == NULL) {
   23100           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fSecureSecondaries");
   23101           0 :                 return -1;
   23102             :         }
   23103             :         {
   23104           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fSecureSecondaries));
   23105           0 :                 if (PyLong_Check(value)) {
   23106           0 :                         unsigned long long test_var;
   23107           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   23108           0 :                         if (PyErr_Occurred() != NULL) {
   23109           0 :                                 return -1;
   23110             :                         }
   23111           0 :                         if (test_var > uint_max) {
   23112           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   23113             :                                   PyLong_Type.tp_name, uint_max, test_var);
   23114           0 :                                 return -1;
   23115             :                         }
   23116           0 :                         object->fSecureSecondaries = test_var;
   23117             :                 } else {
   23118           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   23119             :                           PyLong_Type.tp_name);
   23120           0 :                         return -1;
   23121             :                 }
   23122             :         }
   23123           0 :         return 0;
   23124             : }
   23125             : 
   23126           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_fNotifyLevel(PyObject *obj, void *closure)
   23127             : {
   23128           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   23129           0 :         PyObject *py_fNotifyLevel;
   23130           0 :         py_fNotifyLevel = PyLong_FromUnsignedLongLong((uint32_t)(object->fNotifyLevel));
   23131           0 :         return py_fNotifyLevel;
   23132             : }
   23133             : 
   23134           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_fNotifyLevel(PyObject *py_obj, PyObject *value, void *closure)
   23135             : {
   23136           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   23137           0 :         if (value == NULL) {
   23138           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fNotifyLevel");
   23139           0 :                 return -1;
   23140             :         }
   23141             :         {
   23142           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fNotifyLevel));
   23143           0 :                 if (PyLong_Check(value)) {
   23144           0 :                         unsigned long long test_var;
   23145           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   23146           0 :                         if (PyErr_Occurred() != NULL) {
   23147           0 :                                 return -1;
   23148             :                         }
   23149           0 :                         if (test_var > uint_max) {
   23150           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   23151             :                                   PyLong_Type.tp_name, uint_max, test_var);
   23152           0 :                                 return -1;
   23153             :                         }
   23154           0 :                         object->fNotifyLevel = test_var;
   23155             :                 } else {
   23156           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   23157             :                           PyLong_Type.tp_name);
   23158           0 :                         return -1;
   23159             :                 }
   23160             :         }
   23161           0 :         return 0;
   23162             : }
   23163             : 
   23164           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_dwTimeout(PyObject *obj, void *closure)
   23165             : {
   23166           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   23167           0 :         PyObject *py_dwTimeout;
   23168           0 :         py_dwTimeout = PyLong_FromUnsignedLongLong((uint32_t)(object->dwTimeout));
   23169           0 :         return py_dwTimeout;
   23170             : }
   23171             : 
   23172           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_dwTimeout(PyObject *py_obj, PyObject *value, void *closure)
   23173             : {
   23174           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   23175           0 :         if (value == NULL) {
   23176           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwTimeout");
   23177           0 :                 return -1;
   23178             :         }
   23179             :         {
   23180           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwTimeout));
   23181           0 :                 if (PyLong_Check(value)) {
   23182           0 :                         unsigned long long test_var;
   23183           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   23184           0 :                         if (PyErr_Occurred() != NULL) {
   23185           0 :                                 return -1;
   23186             :                         }
   23187           0 :                         if (test_var > uint_max) {
   23188           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   23189             :                                   PyLong_Type.tp_name, uint_max, test_var);
   23190           0 :                                 return -1;
   23191             :                         }
   23192           0 :                         object->dwTimeout = test_var;
   23193             :                 } else {
   23194           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   23195             :                           PyLong_Type.tp_name);
   23196           0 :                         return -1;
   23197             :                 }
   23198             :         }
   23199           0 :         return 0;
   23200             : }
   23201             : 
   23202           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_fRecurseAfterForwarding(PyObject *obj, void *closure)
   23203             : {
   23204           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   23205           0 :         PyObject *py_fRecurseAfterForwarding;
   23206           0 :         py_fRecurseAfterForwarding = PyLong_FromUnsignedLongLong((uint32_t)(object->fRecurseAfterForwarding));
   23207           0 :         return py_fRecurseAfterForwarding;
   23208             : }
   23209             : 
   23210           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_fRecurseAfterForwarding(PyObject *py_obj, PyObject *value, void *closure)
   23211             : {
   23212           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   23213           0 :         if (value == NULL) {
   23214           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fRecurseAfterForwarding");
   23215           0 :                 return -1;
   23216             :         }
   23217             :         {
   23218           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fRecurseAfterForwarding));
   23219           0 :                 if (PyLong_Check(value)) {
   23220           0 :                         unsigned long long test_var;
   23221           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   23222           0 :                         if (PyErr_Occurred() != NULL) {
   23223           0 :                                 return -1;
   23224             :                         }
   23225           0 :                         if (test_var > uint_max) {
   23226           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   23227             :                                   PyLong_Type.tp_name, uint_max, test_var);
   23228           0 :                                 return -1;
   23229             :                         }
   23230           0 :                         object->fRecurseAfterForwarding = test_var;
   23231             :                 } else {
   23232           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   23233             :                           PyLong_Type.tp_name);
   23234           0 :                         return -1;
   23235             :                 }
   23236             :         }
   23237           0 :         return 0;
   23238             : }
   23239             : 
   23240           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_dwDpFlags(PyObject *obj, void *closure)
   23241             : {
   23242           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   23243           0 :         PyObject *py_dwDpFlags;
   23244           0 :         py_dwDpFlags = PyLong_FromUnsignedLongLong((uint32_t)(object->dwDpFlags));
   23245           0 :         return py_dwDpFlags;
   23246             : }
   23247             : 
   23248         427 : static int py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_dwDpFlags(PyObject *py_obj, PyObject *value, void *closure)
   23249             : {
   23250         427 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   23251         427 :         if (value == NULL) {
   23252           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwDpFlags");
   23253           0 :                 return -1;
   23254             :         }
   23255             :         {
   23256         427 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwDpFlags));
   23257         427 :                 if (PyLong_Check(value)) {
   23258           0 :                         unsigned long long test_var;
   23259         427 :                         test_var = PyLong_AsUnsignedLongLong(value);
   23260         427 :                         if (PyErr_Occurred() != NULL) {
   23261           0 :                                 return -1;
   23262             :                         }
   23263         427 :                         if (test_var > uint_max) {
   23264           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   23265             :                                   PyLong_Type.tp_name, uint_max, test_var);
   23266           0 :                                 return -1;
   23267             :                         }
   23268         427 :                         object->dwDpFlags = test_var;
   23269             :                 } else {
   23270           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   23271             :                           PyLong_Type.tp_name);
   23272           0 :                         return -1;
   23273             :                 }
   23274             :         }
   23275         427 :         return 0;
   23276             : }
   23277             : 
   23278           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_pszDpFqdn(PyObject *obj, void *closure)
   23279             : {
   23280           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   23281           0 :         PyObject *py_pszDpFqdn;
   23282           0 :         if (object->pszDpFqdn == NULL) {
   23283           0 :                 Py_RETURN_NONE;
   23284             :         }
   23285           0 :         if (object->pszDpFqdn == NULL) {
   23286           0 :                 py_pszDpFqdn = Py_None;
   23287           0 :                 Py_INCREF(py_pszDpFqdn);
   23288             :         } else {
   23289           0 :                 if (object->pszDpFqdn == NULL) {
   23290           0 :                         py_pszDpFqdn = Py_None;
   23291           0 :                         Py_INCREF(py_pszDpFqdn);
   23292             :                 } else {
   23293           0 :                         py_pszDpFqdn = PyUnicode_Decode(object->pszDpFqdn, strlen(object->pszDpFqdn), "utf-8", "ignore");
   23294             :                 }
   23295             :         }
   23296           0 :         return py_pszDpFqdn;
   23297             : }
   23298             : 
   23299           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_pszDpFqdn(PyObject *py_obj, PyObject *value, void *closure)
   23300             : {
   23301           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   23302           0 :         if (value == NULL) {
   23303           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszDpFqdn");
   23304           0 :                 return -1;
   23305             :         }
   23306           0 :         if (value == Py_None) {
   23307           0 :                 object->pszDpFqdn = NULL;
   23308             :         } else {
   23309           0 :                 object->pszDpFqdn = NULL;
   23310             :                 {
   23311           0 :                         const char *test_str;
   23312           0 :                         const char *talloc_str;
   23313           0 :                         PyObject *unicode = NULL;
   23314           0 :                         if (PyUnicode_Check(value)) {
   23315           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   23316           0 :                                 if (unicode == NULL) {
   23317           0 :                                         return -1;
   23318             :                                 }
   23319           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   23320           0 :                         } else if (PyBytes_Check(value)) {
   23321           0 :                                 test_str = PyBytes_AS_STRING(value);
   23322             :                         } else {
   23323           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   23324           0 :                                 return -1;
   23325             :                         }
   23326           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   23327           0 :                         if (unicode != NULL) {
   23328           0 :                                 Py_DECREF(unicode);
   23329             :                         }
   23330           0 :                         if (talloc_str == NULL) {
   23331           0 :                                 PyErr_NoMemory();
   23332           0 :                                 return -1;
   23333             :                         }
   23334           0 :                         object->pszDpFqdn = talloc_str;
   23335             :                 }
   23336             :         }
   23337           0 :         return 0;
   23338             : }
   23339             : 
   23340           0 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_dwReserved(PyObject *obj, void *closure)
   23341             : {
   23342           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(obj);
   23343           0 :         PyObject *py_dwReserved;
   23344           0 :         py_dwReserved = PyList_New(32);
   23345           0 :         if (py_dwReserved == NULL) {
   23346           0 :                 return NULL;
   23347             :         }
   23348             :         {
   23349             :                 int dwReserved_cntr_0;
   23350           0 :                 for (dwReserved_cntr_0 = 0; dwReserved_cntr_0 < (32); dwReserved_cntr_0++) {
   23351           0 :                         PyObject *py_dwReserved_0;
   23352           0 :                         py_dwReserved_0 = PyLong_FromUnsignedLongLong((uint32_t)((object->dwReserved)[dwReserved_cntr_0]));
   23353           0 :                         PyList_SetItem(py_dwReserved, dwReserved_cntr_0, py_dwReserved_0);
   23354             :                 }
   23355             :         }
   23356           0 :         return py_dwReserved;
   23357             : }
   23358             : 
   23359           0 : static int py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_dwReserved(PyObject *py_obj, PyObject *value, void *closure)
   23360             : {
   23361           0 :         struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *object = pytalloc_get_ptr(py_obj);
   23362           0 :         if (value == NULL) {
   23363           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved");
   23364           0 :                 return -1;
   23365             :         }
   23366           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
   23367             :         {
   23368           0 :                 int dwReserved_cntr_0;
   23369           0 :                 if (ARRAY_SIZE(object->dwReserved) != PyList_GET_SIZE(value)) {
   23370           0 :                         PyErr_Format(PyExc_TypeError, "Expected list of type %s, length %zu, got %zd", Py_TYPE(value)->tp_name, ARRAY_SIZE(object->dwReserved),  PyList_GET_SIZE(value));
   23371           0 :                         return -1;
   23372             :                 }
   23373           0 :                 for (dwReserved_cntr_0 = 0; dwReserved_cntr_0 < PyList_GET_SIZE(value); dwReserved_cntr_0++) {
   23374           0 :                         if (PyList_GET_ITEM(value, dwReserved_cntr_0) == NULL) {
   23375           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->dwReserved)[dwReserved_cntr_0]");
   23376           0 :                                 return -1;
   23377             :                         }
   23378             :                         {
   23379           0 :                                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof((object->dwReserved)[dwReserved_cntr_0]));
   23380           0 :                                 if (PyLong_Check(PyList_GET_ITEM(value, dwReserved_cntr_0))) {
   23381           0 :                                         unsigned long long test_var;
   23382           0 :                                         test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, dwReserved_cntr_0));
   23383           0 :                                         if (PyErr_Occurred() != NULL) {
   23384           0 :                                                 return -1;
   23385             :                                         }
   23386           0 :                                         if (test_var > uint_max) {
   23387           0 :                                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   23388             :                                                   PyLong_Type.tp_name, uint_max, test_var);
   23389           0 :                                                 return -1;
   23390             :                                         }
   23391           0 :                                         (object->dwReserved)[dwReserved_cntr_0] = test_var;
   23392             :                                 } else {
   23393           0 :                                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   23394             :                                           PyLong_Type.tp_name);
   23395           0 :                                         return -1;
   23396             :                                 }
   23397             :                         }
   23398             :                 }
   23399             :         }
   23400           0 :         return 0;
   23401             : }
   23402             : 
   23403             : static PyGetSetDef py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_getsetters[] = {
   23404             :         {
   23405             :                 .name = discard_const_p(char, "dwRpcStructureVersion"),
   23406             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_dwRpcStructureVersion,
   23407             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_dwRpcStructureVersion,
   23408             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   23409             :         },
   23410             :         {
   23411             :                 .name = discard_const_p(char, "dwReserved0"),
   23412             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_dwReserved0,
   23413             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_dwReserved0,
   23414             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   23415             :         },
   23416             :         {
   23417             :                 .name = discard_const_p(char, "pszZoneName"),
   23418             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_pszZoneName,
   23419             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_pszZoneName,
   23420             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   23421             :         },
   23422             :         {
   23423             :                 .name = discard_const_p(char, "dwZoneType"),
   23424             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_dwZoneType,
   23425             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_dwZoneType,
   23426             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   23427             :         },
   23428             :         {
   23429             :                 .name = discard_const_p(char, "fAllowUpdate"),
   23430             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_fAllowUpdate,
   23431             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_fAllowUpdate,
   23432             :                 .doc = discard_const_p(char, "PIDL-generated element of base type dns_zone_update")
   23433             :         },
   23434             :         {
   23435             :                 .name = discard_const_p(char, "fAging"),
   23436             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_fAging,
   23437             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_fAging,
   23438             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   23439             :         },
   23440             :         {
   23441             :                 .name = discard_const_p(char, "dwFlags"),
   23442             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_dwFlags,
   23443             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_dwFlags,
   23444             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   23445             :         },
   23446             :         {
   23447             :                 .name = discard_const_p(char, "pszDataFile"),
   23448             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_pszDataFile,
   23449             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_pszDataFile,
   23450             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   23451             :         },
   23452             :         {
   23453             :                 .name = discard_const_p(char, "fDsIntegrated"),
   23454             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_fDsIntegrated,
   23455             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_fDsIntegrated,
   23456             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   23457             :         },
   23458             :         {
   23459             :                 .name = discard_const_p(char, "fLoadExisting"),
   23460             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_fLoadExisting,
   23461             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_fLoadExisting,
   23462             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   23463             :         },
   23464             :         {
   23465             :                 .name = discard_const_p(char, "pszAdmin"),
   23466             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_pszAdmin,
   23467             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_pszAdmin,
   23468             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   23469             :         },
   23470             :         {
   23471             :                 .name = discard_const_p(char, "aipMasters"),
   23472             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_aipMasters,
   23473             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_aipMasters,
   23474             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ADDR_ARRAY")
   23475             :         },
   23476             :         {
   23477             :                 .name = discard_const_p(char, "aipSecondaries"),
   23478             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_aipSecondaries,
   23479             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_aipSecondaries,
   23480             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ADDR_ARRAY")
   23481             :         },
   23482             :         {
   23483             :                 .name = discard_const_p(char, "fSecureSecondaries"),
   23484             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_fSecureSecondaries,
   23485             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_fSecureSecondaries,
   23486             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ZONE_SECONDARY_SECURITY")
   23487             :         },
   23488             :         {
   23489             :                 .name = discard_const_p(char, "fNotifyLevel"),
   23490             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_fNotifyLevel,
   23491             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_fNotifyLevel,
   23492             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ZONE_NOTIFY_LEVEL")
   23493             :         },
   23494             :         {
   23495             :                 .name = discard_const_p(char, "dwTimeout"),
   23496             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_dwTimeout,
   23497             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_dwTimeout,
   23498             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   23499             :         },
   23500             :         {
   23501             :                 .name = discard_const_p(char, "fRecurseAfterForwarding"),
   23502             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_fRecurseAfterForwarding,
   23503             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_fRecurseAfterForwarding,
   23504             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   23505             :         },
   23506             :         {
   23507             :                 .name = discard_const_p(char, "dwDpFlags"),
   23508             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_dwDpFlags,
   23509             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_dwDpFlags,
   23510             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   23511             :         },
   23512             :         {
   23513             :                 .name = discard_const_p(char, "pszDpFqdn"),
   23514             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_pszDpFqdn,
   23515             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_pszDpFqdn,
   23516             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   23517             :         },
   23518             :         {
   23519             :                 .name = discard_const_p(char, "dwReserved"),
   23520             :                 .get = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_get_dwReserved,
   23521             :                 .set = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_set_dwReserved,
   23522             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   23523             :         },
   23524             :         { .name = NULL }
   23525             : };
   23526             : 
   23527         427 : static PyObject *py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   23528             : {
   23529         427 :         return pytalloc_new(struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN, type);
   23530             : }
   23531             : 
   23532             : 
   23533             : static PyTypeObject DNS_RPC_ZONE_CREATE_INFO_LONGHORN_Type = {
   23534             :         PyVarObject_HEAD_INIT(NULL, 0)
   23535             :         .tp_name = "dnsserver.DNS_RPC_ZONE_CREATE_INFO_LONGHORN",
   23536             :         .tp_getset = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_getsetters,
   23537             :         .tp_methods = NULL,
   23538             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   23539             :         .tp_new = py_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_new,
   23540             : };
   23541             : 
   23542             : 
   23543           0 : static PyObject *py_DNS_RPC_ZONE_EXPORT_INFO_get_dwRpcStructureVersion(PyObject *obj, void *closure)
   23544             : {
   23545           0 :         struct DNS_RPC_ZONE_EXPORT_INFO *object = pytalloc_get_ptr(obj);
   23546           0 :         PyObject *py_dwRpcStructureVersion;
   23547           0 :         py_dwRpcStructureVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcStructureVersion));
   23548           0 :         return py_dwRpcStructureVersion;
   23549             : }
   23550             : 
   23551           0 : static int py_DNS_RPC_ZONE_EXPORT_INFO_set_dwRpcStructureVersion(PyObject *py_obj, PyObject *value, void *closure)
   23552             : {
   23553           0 :         struct DNS_RPC_ZONE_EXPORT_INFO *object = pytalloc_get_ptr(py_obj);
   23554           0 :         if (value == NULL) {
   23555           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcStructureVersion");
   23556           0 :                 return -1;
   23557             :         }
   23558             :         {
   23559           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcStructureVersion));
   23560           0 :                 if (PyLong_Check(value)) {
   23561           0 :                         unsigned long long test_var;
   23562           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   23563           0 :                         if (PyErr_Occurred() != NULL) {
   23564           0 :                                 return -1;
   23565             :                         }
   23566           0 :                         if (test_var > uint_max) {
   23567           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   23568             :                                   PyLong_Type.tp_name, uint_max, test_var);
   23569           0 :                                 return -1;
   23570             :                         }
   23571           0 :                         object->dwRpcStructureVersion = test_var;
   23572             :                 } else {
   23573           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   23574             :                           PyLong_Type.tp_name);
   23575           0 :                         return -1;
   23576             :                 }
   23577             :         }
   23578           0 :         return 0;
   23579             : }
   23580             : 
   23581           0 : static PyObject *py_DNS_RPC_ZONE_EXPORT_INFO_get_dwReserved0(PyObject *obj, void *closure)
   23582             : {
   23583           0 :         struct DNS_RPC_ZONE_EXPORT_INFO *object = pytalloc_get_ptr(obj);
   23584           0 :         PyObject *py_dwReserved0;
   23585           0 :         py_dwReserved0 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved0));
   23586           0 :         return py_dwReserved0;
   23587             : }
   23588             : 
   23589           0 : static int py_DNS_RPC_ZONE_EXPORT_INFO_set_dwReserved0(PyObject *py_obj, PyObject *value, void *closure)
   23590             : {
   23591           0 :         struct DNS_RPC_ZONE_EXPORT_INFO *object = pytalloc_get_ptr(py_obj);
   23592           0 :         if (value == NULL) {
   23593           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved0");
   23594           0 :                 return -1;
   23595             :         }
   23596             :         {
   23597           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved0));
   23598           0 :                 if (PyLong_Check(value)) {
   23599           0 :                         unsigned long long test_var;
   23600           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   23601           0 :                         if (PyErr_Occurred() != NULL) {
   23602           0 :                                 return -1;
   23603             :                         }
   23604           0 :                         if (test_var > uint_max) {
   23605           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   23606             :                                   PyLong_Type.tp_name, uint_max, test_var);
   23607           0 :                                 return -1;
   23608             :                         }
   23609           0 :                         object->dwReserved0 = test_var;
   23610             :                 } else {
   23611           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   23612             :                           PyLong_Type.tp_name);
   23613           0 :                         return -1;
   23614             :                 }
   23615             :         }
   23616           0 :         return 0;
   23617             : }
   23618             : 
   23619           0 : static PyObject *py_DNS_RPC_ZONE_EXPORT_INFO_get_pszZoneExportFile(PyObject *obj, void *closure)
   23620             : {
   23621           0 :         struct DNS_RPC_ZONE_EXPORT_INFO *object = pytalloc_get_ptr(obj);
   23622           0 :         PyObject *py_pszZoneExportFile;
   23623           0 :         if (object->pszZoneExportFile == NULL) {
   23624           0 :                 Py_RETURN_NONE;
   23625             :         }
   23626           0 :         if (object->pszZoneExportFile == NULL) {
   23627           0 :                 py_pszZoneExportFile = Py_None;
   23628           0 :                 Py_INCREF(py_pszZoneExportFile);
   23629             :         } else {
   23630           0 :                 if (object->pszZoneExportFile == NULL) {
   23631           0 :                         py_pszZoneExportFile = Py_None;
   23632           0 :                         Py_INCREF(py_pszZoneExportFile);
   23633             :                 } else {
   23634           0 :                         py_pszZoneExportFile = PyUnicode_Decode(object->pszZoneExportFile, strlen(object->pszZoneExportFile), "utf-8", "ignore");
   23635             :                 }
   23636             :         }
   23637           0 :         return py_pszZoneExportFile;
   23638             : }
   23639             : 
   23640           0 : static int py_DNS_RPC_ZONE_EXPORT_INFO_set_pszZoneExportFile(PyObject *py_obj, PyObject *value, void *closure)
   23641             : {
   23642           0 :         struct DNS_RPC_ZONE_EXPORT_INFO *object = pytalloc_get_ptr(py_obj);
   23643           0 :         if (value == NULL) {
   23644           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszZoneExportFile");
   23645           0 :                 return -1;
   23646             :         }
   23647           0 :         if (value == Py_None) {
   23648           0 :                 object->pszZoneExportFile = NULL;
   23649             :         } else {
   23650           0 :                 object->pszZoneExportFile = NULL;
   23651             :                 {
   23652           0 :                         const char *test_str;
   23653           0 :                         const char *talloc_str;
   23654           0 :                         PyObject *unicode = NULL;
   23655           0 :                         if (PyUnicode_Check(value)) {
   23656           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   23657           0 :                                 if (unicode == NULL) {
   23658           0 :                                         return -1;
   23659             :                                 }
   23660           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   23661           0 :                         } else if (PyBytes_Check(value)) {
   23662           0 :                                 test_str = PyBytes_AS_STRING(value);
   23663             :                         } else {
   23664           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   23665           0 :                                 return -1;
   23666             :                         }
   23667           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   23668           0 :                         if (unicode != NULL) {
   23669           0 :                                 Py_DECREF(unicode);
   23670             :                         }
   23671           0 :                         if (talloc_str == NULL) {
   23672           0 :                                 PyErr_NoMemory();
   23673           0 :                                 return -1;
   23674             :                         }
   23675           0 :                         object->pszZoneExportFile = talloc_str;
   23676             :                 }
   23677             :         }
   23678           0 :         return 0;
   23679             : }
   23680             : 
   23681             : static PyGetSetDef py_DNS_RPC_ZONE_EXPORT_INFO_getsetters[] = {
   23682             :         {
   23683             :                 .name = discard_const_p(char, "dwRpcStructureVersion"),
   23684             :                 .get = py_DNS_RPC_ZONE_EXPORT_INFO_get_dwRpcStructureVersion,
   23685             :                 .set = py_DNS_RPC_ZONE_EXPORT_INFO_set_dwRpcStructureVersion,
   23686             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   23687             :         },
   23688             :         {
   23689             :                 .name = discard_const_p(char, "dwReserved0"),
   23690             :                 .get = py_DNS_RPC_ZONE_EXPORT_INFO_get_dwReserved0,
   23691             :                 .set = py_DNS_RPC_ZONE_EXPORT_INFO_set_dwReserved0,
   23692             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   23693             :         },
   23694             :         {
   23695             :                 .name = discard_const_p(char, "pszZoneExportFile"),
   23696             :                 .get = py_DNS_RPC_ZONE_EXPORT_INFO_get_pszZoneExportFile,
   23697             :                 .set = py_DNS_RPC_ZONE_EXPORT_INFO_set_pszZoneExportFile,
   23698             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   23699             :         },
   23700             :         { .name = NULL }
   23701             : };
   23702             : 
   23703           0 : static PyObject *py_DNS_RPC_ZONE_EXPORT_INFO_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   23704             : {
   23705           0 :         return pytalloc_new(struct DNS_RPC_ZONE_EXPORT_INFO, type);
   23706             : }
   23707             : 
   23708             : 
   23709             : static PyTypeObject DNS_RPC_ZONE_EXPORT_INFO_Type = {
   23710             :         PyVarObject_HEAD_INIT(NULL, 0)
   23711             :         .tp_name = "dnsserver.DNS_RPC_ZONE_EXPORT_INFO",
   23712             :         .tp_getset = py_DNS_RPC_ZONE_EXPORT_INFO_getsetters,
   23713             :         .tp_methods = NULL,
   23714             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   23715             :         .tp_new = py_DNS_RPC_ZONE_EXPORT_INFO_new,
   23716             : };
   23717             : 
   23718             : 
   23719           0 : static PyObject *py_DNS_RPC_ENUM_ZONES_FILTER_get_dwRpcStructureVersion(PyObject *obj, void *closure)
   23720             : {
   23721           0 :         struct DNS_RPC_ENUM_ZONES_FILTER *object = pytalloc_get_ptr(obj);
   23722           0 :         PyObject *py_dwRpcStructureVersion;
   23723           0 :         py_dwRpcStructureVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcStructureVersion));
   23724           0 :         return py_dwRpcStructureVersion;
   23725             : }
   23726             : 
   23727           0 : static int py_DNS_RPC_ENUM_ZONES_FILTER_set_dwRpcStructureVersion(PyObject *py_obj, PyObject *value, void *closure)
   23728             : {
   23729           0 :         struct DNS_RPC_ENUM_ZONES_FILTER *object = pytalloc_get_ptr(py_obj);
   23730           0 :         if (value == NULL) {
   23731           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcStructureVersion");
   23732           0 :                 return -1;
   23733             :         }
   23734             :         {
   23735           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcStructureVersion));
   23736           0 :                 if (PyLong_Check(value)) {
   23737           0 :                         unsigned long long test_var;
   23738           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   23739           0 :                         if (PyErr_Occurred() != NULL) {
   23740           0 :                                 return -1;
   23741             :                         }
   23742           0 :                         if (test_var > uint_max) {
   23743           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   23744             :                                   PyLong_Type.tp_name, uint_max, test_var);
   23745           0 :                                 return -1;
   23746             :                         }
   23747           0 :                         object->dwRpcStructureVersion = test_var;
   23748             :                 } else {
   23749           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   23750             :                           PyLong_Type.tp_name);
   23751           0 :                         return -1;
   23752             :                 }
   23753             :         }
   23754           0 :         return 0;
   23755             : }
   23756             : 
   23757           0 : static PyObject *py_DNS_RPC_ENUM_ZONES_FILTER_get_dwReserved0(PyObject *obj, void *closure)
   23758             : {
   23759           0 :         struct DNS_RPC_ENUM_ZONES_FILTER *object = pytalloc_get_ptr(obj);
   23760           0 :         PyObject *py_dwReserved0;
   23761           0 :         py_dwReserved0 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved0));
   23762           0 :         return py_dwReserved0;
   23763             : }
   23764             : 
   23765           0 : static int py_DNS_RPC_ENUM_ZONES_FILTER_set_dwReserved0(PyObject *py_obj, PyObject *value, void *closure)
   23766             : {
   23767           0 :         struct DNS_RPC_ENUM_ZONES_FILTER *object = pytalloc_get_ptr(py_obj);
   23768           0 :         if (value == NULL) {
   23769           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved0");
   23770           0 :                 return -1;
   23771             :         }
   23772             :         {
   23773           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved0));
   23774           0 :                 if (PyLong_Check(value)) {
   23775           0 :                         unsigned long long test_var;
   23776           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   23777           0 :                         if (PyErr_Occurred() != NULL) {
   23778           0 :                                 return -1;
   23779             :                         }
   23780           0 :                         if (test_var > uint_max) {
   23781           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   23782             :                                   PyLong_Type.tp_name, uint_max, test_var);
   23783           0 :                                 return -1;
   23784             :                         }
   23785           0 :                         object->dwReserved0 = test_var;
   23786             :                 } else {
   23787           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   23788             :                           PyLong_Type.tp_name);
   23789           0 :                         return -1;
   23790             :                 }
   23791             :         }
   23792           0 :         return 0;
   23793             : }
   23794             : 
   23795           0 : static PyObject *py_DNS_RPC_ENUM_ZONES_FILTER_get_dwFilter(PyObject *obj, void *closure)
   23796             : {
   23797           0 :         struct DNS_RPC_ENUM_ZONES_FILTER *object = pytalloc_get_ptr(obj);
   23798           0 :         PyObject *py_dwFilter;
   23799           0 :         py_dwFilter = PyLong_FromUnsignedLongLong((uint32_t)(object->dwFilter));
   23800           0 :         return py_dwFilter;
   23801             : }
   23802             : 
   23803           0 : static int py_DNS_RPC_ENUM_ZONES_FILTER_set_dwFilter(PyObject *py_obj, PyObject *value, void *closure)
   23804             : {
   23805           0 :         struct DNS_RPC_ENUM_ZONES_FILTER *object = pytalloc_get_ptr(py_obj);
   23806           0 :         if (value == NULL) {
   23807           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwFilter");
   23808           0 :                 return -1;
   23809             :         }
   23810             :         {
   23811           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwFilter));
   23812           0 :                 if (PyLong_Check(value)) {
   23813           0 :                         unsigned long long test_var;
   23814           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   23815           0 :                         if (PyErr_Occurred() != NULL) {
   23816           0 :                                 return -1;
   23817             :                         }
   23818           0 :                         if (test_var > uint_max) {
   23819           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   23820             :                                   PyLong_Type.tp_name, uint_max, test_var);
   23821           0 :                                 return -1;
   23822             :                         }
   23823           0 :                         object->dwFilter = test_var;
   23824             :                 } else {
   23825           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   23826             :                           PyLong_Type.tp_name);
   23827           0 :                         return -1;
   23828             :                 }
   23829             :         }
   23830           0 :         return 0;
   23831             : }
   23832             : 
   23833           0 : static PyObject *py_DNS_RPC_ENUM_ZONES_FILTER_get_pszPartitionFqdn(PyObject *obj, void *closure)
   23834             : {
   23835           0 :         struct DNS_RPC_ENUM_ZONES_FILTER *object = pytalloc_get_ptr(obj);
   23836           0 :         PyObject *py_pszPartitionFqdn;
   23837           0 :         if (object->pszPartitionFqdn == NULL) {
   23838           0 :                 Py_RETURN_NONE;
   23839             :         }
   23840           0 :         if (object->pszPartitionFqdn == NULL) {
   23841           0 :                 py_pszPartitionFqdn = Py_None;
   23842           0 :                 Py_INCREF(py_pszPartitionFqdn);
   23843             :         } else {
   23844           0 :                 if (object->pszPartitionFqdn == NULL) {
   23845           0 :                         py_pszPartitionFqdn = Py_None;
   23846           0 :                         Py_INCREF(py_pszPartitionFqdn);
   23847             :                 } else {
   23848           0 :                         py_pszPartitionFqdn = PyUnicode_Decode(object->pszPartitionFqdn, strlen(object->pszPartitionFqdn), "utf-8", "ignore");
   23849             :                 }
   23850             :         }
   23851           0 :         return py_pszPartitionFqdn;
   23852             : }
   23853             : 
   23854           0 : static int py_DNS_RPC_ENUM_ZONES_FILTER_set_pszPartitionFqdn(PyObject *py_obj, PyObject *value, void *closure)
   23855             : {
   23856           0 :         struct DNS_RPC_ENUM_ZONES_FILTER *object = pytalloc_get_ptr(py_obj);
   23857           0 :         if (value == NULL) {
   23858           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszPartitionFqdn");
   23859           0 :                 return -1;
   23860             :         }
   23861           0 :         if (value == Py_None) {
   23862           0 :                 object->pszPartitionFqdn = NULL;
   23863             :         } else {
   23864           0 :                 object->pszPartitionFqdn = NULL;
   23865             :                 {
   23866           0 :                         const char *test_str;
   23867           0 :                         const char *talloc_str;
   23868           0 :                         PyObject *unicode = NULL;
   23869           0 :                         if (PyUnicode_Check(value)) {
   23870           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   23871           0 :                                 if (unicode == NULL) {
   23872           0 :                                         return -1;
   23873             :                                 }
   23874           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   23875           0 :                         } else if (PyBytes_Check(value)) {
   23876           0 :                                 test_str = PyBytes_AS_STRING(value);
   23877             :                         } else {
   23878           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   23879           0 :                                 return -1;
   23880             :                         }
   23881           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   23882           0 :                         if (unicode != NULL) {
   23883           0 :                                 Py_DECREF(unicode);
   23884             :                         }
   23885           0 :                         if (talloc_str == NULL) {
   23886           0 :                                 PyErr_NoMemory();
   23887           0 :                                 return -1;
   23888             :                         }
   23889           0 :                         object->pszPartitionFqdn = talloc_str;
   23890             :                 }
   23891             :         }
   23892           0 :         return 0;
   23893             : }
   23894             : 
   23895           0 : static PyObject *py_DNS_RPC_ENUM_ZONES_FILTER_get_pszQueryString(PyObject *obj, void *closure)
   23896             : {
   23897           0 :         struct DNS_RPC_ENUM_ZONES_FILTER *object = pytalloc_get_ptr(obj);
   23898           0 :         PyObject *py_pszQueryString;
   23899           0 :         if (object->pszQueryString == NULL) {
   23900           0 :                 Py_RETURN_NONE;
   23901             :         }
   23902           0 :         if (object->pszQueryString == NULL) {
   23903           0 :                 py_pszQueryString = Py_None;
   23904           0 :                 Py_INCREF(py_pszQueryString);
   23905             :         } else {
   23906           0 :                 if (object->pszQueryString == NULL) {
   23907           0 :                         py_pszQueryString = Py_None;
   23908           0 :                         Py_INCREF(py_pszQueryString);
   23909             :                 } else {
   23910           0 :                         py_pszQueryString = PyUnicode_Decode(object->pszQueryString, strlen(object->pszQueryString), "utf-8", "ignore");
   23911             :                 }
   23912             :         }
   23913           0 :         return py_pszQueryString;
   23914             : }
   23915             : 
   23916           0 : static int py_DNS_RPC_ENUM_ZONES_FILTER_set_pszQueryString(PyObject *py_obj, PyObject *value, void *closure)
   23917             : {
   23918           0 :         struct DNS_RPC_ENUM_ZONES_FILTER *object = pytalloc_get_ptr(py_obj);
   23919           0 :         if (value == NULL) {
   23920           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszQueryString");
   23921           0 :                 return -1;
   23922             :         }
   23923           0 :         if (value == Py_None) {
   23924           0 :                 object->pszQueryString = NULL;
   23925             :         } else {
   23926           0 :                 object->pszQueryString = NULL;
   23927             :                 {
   23928           0 :                         const char *test_str;
   23929           0 :                         const char *talloc_str;
   23930           0 :                         PyObject *unicode = NULL;
   23931           0 :                         if (PyUnicode_Check(value)) {
   23932           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   23933           0 :                                 if (unicode == NULL) {
   23934           0 :                                         return -1;
   23935             :                                 }
   23936           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   23937           0 :                         } else if (PyBytes_Check(value)) {
   23938           0 :                                 test_str = PyBytes_AS_STRING(value);
   23939             :                         } else {
   23940           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   23941           0 :                                 return -1;
   23942             :                         }
   23943           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   23944           0 :                         if (unicode != NULL) {
   23945           0 :                                 Py_DECREF(unicode);
   23946             :                         }
   23947           0 :                         if (talloc_str == NULL) {
   23948           0 :                                 PyErr_NoMemory();
   23949           0 :                                 return -1;
   23950             :                         }
   23951           0 :                         object->pszQueryString = talloc_str;
   23952             :                 }
   23953             :         }
   23954           0 :         return 0;
   23955             : }
   23956             : 
   23957           0 : static PyObject *py_DNS_RPC_ENUM_ZONES_FILTER_get_pszReserved(PyObject *obj, void *closure)
   23958             : {
   23959           0 :         struct DNS_RPC_ENUM_ZONES_FILTER *object = pytalloc_get_ptr(obj);
   23960           0 :         PyObject *py_pszReserved;
   23961           0 :         py_pszReserved = PyList_New(6);
   23962           0 :         if (py_pszReserved == NULL) {
   23963           0 :                 return NULL;
   23964             :         }
   23965             :         {
   23966             :                 int pszReserved_cntr_0;
   23967           0 :                 for (pszReserved_cntr_0 = 0; pszReserved_cntr_0 < (6); pszReserved_cntr_0++) {
   23968           0 :                         PyObject *py_pszReserved_0;
   23969           0 :                         py_pszReserved_0 = pytalloc_reference_ex(&DNS_EXTENSION_Type, pytalloc_get_mem_ctx(obj), &(object->pszReserved)[pszReserved_cntr_0]);
   23970           0 :                         PyList_SetItem(py_pszReserved, pszReserved_cntr_0, py_pszReserved_0);
   23971             :                 }
   23972             :         }
   23973           0 :         return py_pszReserved;
   23974             : }
   23975             : 
   23976           0 : static int py_DNS_RPC_ENUM_ZONES_FILTER_set_pszReserved(PyObject *py_obj, PyObject *value, void *closure)
   23977             : {
   23978           0 :         struct DNS_RPC_ENUM_ZONES_FILTER *object = pytalloc_get_ptr(py_obj);
   23979           0 :         if (value == NULL) {
   23980           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszReserved");
   23981           0 :                 return -1;
   23982             :         }
   23983           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
   23984             :         {
   23985           0 :                 int pszReserved_cntr_0;
   23986           0 :                 if (ARRAY_SIZE(object->pszReserved) != PyList_GET_SIZE(value)) {
   23987           0 :                         PyErr_Format(PyExc_TypeError, "Expected list of type %s, length %zu, got %zd", Py_TYPE(value)->tp_name, ARRAY_SIZE(object->pszReserved),  PyList_GET_SIZE(value));
   23988           0 :                         return -1;
   23989             :                 }
   23990           0 :                 for (pszReserved_cntr_0 = 0; pszReserved_cntr_0 < PyList_GET_SIZE(value); pszReserved_cntr_0++) {
   23991           0 :                         if (PyList_GET_ITEM(value, pszReserved_cntr_0) == NULL) {
   23992           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->pszReserved)[pszReserved_cntr_0]");
   23993           0 :                                 return -1;
   23994             :                         }
   23995           0 :                         PY_CHECK_TYPE(&DNS_EXTENSION_Type, PyList_GET_ITEM(value, pszReserved_cntr_0), return -1;);
   23996           0 :                         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(PyList_GET_ITEM(value, pszReserved_cntr_0))) == NULL) {
   23997           0 :                                 PyErr_NoMemory();
   23998           0 :                                 return -1;
   23999             :                         }
   24000           0 :                         (object->pszReserved)[pszReserved_cntr_0] = *(struct DNS_EXTENSION *)pytalloc_get_ptr(PyList_GET_ITEM(value, pszReserved_cntr_0));
   24001             :                 }
   24002             :         }
   24003           0 :         return 0;
   24004             : }
   24005             : 
   24006             : static PyGetSetDef py_DNS_RPC_ENUM_ZONES_FILTER_getsetters[] = {
   24007             :         {
   24008             :                 .name = discard_const_p(char, "dwRpcStructureVersion"),
   24009             :                 .get = py_DNS_RPC_ENUM_ZONES_FILTER_get_dwRpcStructureVersion,
   24010             :                 .set = py_DNS_RPC_ENUM_ZONES_FILTER_set_dwRpcStructureVersion,
   24011             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   24012             :         },
   24013             :         {
   24014             :                 .name = discard_const_p(char, "dwReserved0"),
   24015             :                 .get = py_DNS_RPC_ENUM_ZONES_FILTER_get_dwReserved0,
   24016             :                 .set = py_DNS_RPC_ENUM_ZONES_FILTER_set_dwReserved0,
   24017             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   24018             :         },
   24019             :         {
   24020             :                 .name = discard_const_p(char, "dwFilter"),
   24021             :                 .get = py_DNS_RPC_ENUM_ZONES_FILTER_get_dwFilter,
   24022             :                 .set = py_DNS_RPC_ENUM_ZONES_FILTER_set_dwFilter,
   24023             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   24024             :         },
   24025             :         {
   24026             :                 .name = discard_const_p(char, "pszPartitionFqdn"),
   24027             :                 .get = py_DNS_RPC_ENUM_ZONES_FILTER_get_pszPartitionFqdn,
   24028             :                 .set = py_DNS_RPC_ENUM_ZONES_FILTER_set_pszPartitionFqdn,
   24029             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   24030             :         },
   24031             :         {
   24032             :                 .name = discard_const_p(char, "pszQueryString"),
   24033             :                 .get = py_DNS_RPC_ENUM_ZONES_FILTER_get_pszQueryString,
   24034             :                 .set = py_DNS_RPC_ENUM_ZONES_FILTER_set_pszQueryString,
   24035             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   24036             :         },
   24037             :         {
   24038             :                 .name = discard_const_p(char, "pszReserved"),
   24039             :                 .get = py_DNS_RPC_ENUM_ZONES_FILTER_get_pszReserved,
   24040             :                 .set = py_DNS_RPC_ENUM_ZONES_FILTER_set_pszReserved,
   24041             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_EXTENSION")
   24042             :         },
   24043             :         { .name = NULL }
   24044             : };
   24045             : 
   24046           0 : static PyObject *py_DNS_RPC_ENUM_ZONES_FILTER_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   24047             : {
   24048           0 :         return pytalloc_new(struct DNS_RPC_ENUM_ZONES_FILTER, type);
   24049             : }
   24050             : 
   24051             : 
   24052             : static PyTypeObject DNS_RPC_ENUM_ZONES_FILTER_Type = {
   24053             :         PyVarObject_HEAD_INIT(NULL, 0)
   24054             :         .tp_name = "dnsserver.DNS_RPC_ENUM_ZONES_FILTER",
   24055             :         .tp_getset = py_DNS_RPC_ENUM_ZONES_FILTER_getsetters,
   24056             :         .tp_methods = NULL,
   24057             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   24058             :         .tp_new = py_DNS_RPC_ENUM_ZONES_FILTER_new,
   24059             : };
   24060             : 
   24061             : 
   24062           0 : static PyObject *py_DNS_RPC_FORWARDERS_W2K_get_fRecurseAfterForwarding(PyObject *obj, void *closure)
   24063             : {
   24064           0 :         struct DNS_RPC_FORWARDERS_W2K *object = pytalloc_get_ptr(obj);
   24065           0 :         PyObject *py_fRecurseAfterForwarding;
   24066           0 :         py_fRecurseAfterForwarding = PyLong_FromUnsignedLongLong((uint32_t)(object->fRecurseAfterForwarding));
   24067           0 :         return py_fRecurseAfterForwarding;
   24068             : }
   24069             : 
   24070           0 : static int py_DNS_RPC_FORWARDERS_W2K_set_fRecurseAfterForwarding(PyObject *py_obj, PyObject *value, void *closure)
   24071             : {
   24072           0 :         struct DNS_RPC_FORWARDERS_W2K *object = pytalloc_get_ptr(py_obj);
   24073           0 :         if (value == NULL) {
   24074           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fRecurseAfterForwarding");
   24075           0 :                 return -1;
   24076             :         }
   24077             :         {
   24078           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fRecurseAfterForwarding));
   24079           0 :                 if (PyLong_Check(value)) {
   24080           0 :                         unsigned long long test_var;
   24081           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   24082           0 :                         if (PyErr_Occurred() != NULL) {
   24083           0 :                                 return -1;
   24084             :                         }
   24085           0 :                         if (test_var > uint_max) {
   24086           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   24087             :                                   PyLong_Type.tp_name, uint_max, test_var);
   24088           0 :                                 return -1;
   24089             :                         }
   24090           0 :                         object->fRecurseAfterForwarding = test_var;
   24091             :                 } else {
   24092           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   24093             :                           PyLong_Type.tp_name);
   24094           0 :                         return -1;
   24095             :                 }
   24096             :         }
   24097           0 :         return 0;
   24098             : }
   24099             : 
   24100           0 : static PyObject *py_DNS_RPC_FORWARDERS_W2K_get_dwForwardTimeout(PyObject *obj, void *closure)
   24101             : {
   24102           0 :         struct DNS_RPC_FORWARDERS_W2K *object = pytalloc_get_ptr(obj);
   24103           0 :         PyObject *py_dwForwardTimeout;
   24104           0 :         py_dwForwardTimeout = PyLong_FromUnsignedLongLong((uint32_t)(object->dwForwardTimeout));
   24105           0 :         return py_dwForwardTimeout;
   24106             : }
   24107             : 
   24108           0 : static int py_DNS_RPC_FORWARDERS_W2K_set_dwForwardTimeout(PyObject *py_obj, PyObject *value, void *closure)
   24109             : {
   24110           0 :         struct DNS_RPC_FORWARDERS_W2K *object = pytalloc_get_ptr(py_obj);
   24111           0 :         if (value == NULL) {
   24112           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwForwardTimeout");
   24113           0 :                 return -1;
   24114             :         }
   24115             :         {
   24116           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwForwardTimeout));
   24117           0 :                 if (PyLong_Check(value)) {
   24118           0 :                         unsigned long long test_var;
   24119           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   24120           0 :                         if (PyErr_Occurred() != NULL) {
   24121           0 :                                 return -1;
   24122             :                         }
   24123           0 :                         if (test_var > uint_max) {
   24124           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   24125             :                                   PyLong_Type.tp_name, uint_max, test_var);
   24126           0 :                                 return -1;
   24127             :                         }
   24128           0 :                         object->dwForwardTimeout = test_var;
   24129             :                 } else {
   24130           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   24131             :                           PyLong_Type.tp_name);
   24132           0 :                         return -1;
   24133             :                 }
   24134             :         }
   24135           0 :         return 0;
   24136             : }
   24137             : 
   24138           0 : static PyObject *py_DNS_RPC_FORWARDERS_W2K_get_aipForwarders(PyObject *obj, void *closure)
   24139             : {
   24140           0 :         struct DNS_RPC_FORWARDERS_W2K *object = pytalloc_get_ptr(obj);
   24141           0 :         PyObject *py_aipForwarders;
   24142           0 :         if (object->aipForwarders == NULL) {
   24143           0 :                 Py_RETURN_NONE;
   24144             :         }
   24145           0 :         if (object->aipForwarders == NULL) {
   24146           0 :                 py_aipForwarders = Py_None;
   24147           0 :                 Py_INCREF(py_aipForwarders);
   24148             :         } else {
   24149           0 :                 py_aipForwarders = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipForwarders, object->aipForwarders);
   24150             :         }
   24151           0 :         return py_aipForwarders;
   24152             : }
   24153             : 
   24154           0 : static int py_DNS_RPC_FORWARDERS_W2K_set_aipForwarders(PyObject *py_obj, PyObject *value, void *closure)
   24155             : {
   24156           0 :         struct DNS_RPC_FORWARDERS_W2K *object = pytalloc_get_ptr(py_obj);
   24157           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipForwarders));
   24158           0 :         if (value == NULL) {
   24159           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipForwarders");
   24160           0 :                 return -1;
   24161             :         }
   24162           0 :         if (value == Py_None) {
   24163           0 :                 object->aipForwarders = NULL;
   24164             :         } else {
   24165           0 :                 object->aipForwarders = NULL;
   24166           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
   24167           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   24168           0 :                         PyErr_NoMemory();
   24169           0 :                         return -1;
   24170             :                 }
   24171           0 :                 object->aipForwarders = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
   24172             :         }
   24173           0 :         return 0;
   24174             : }
   24175             : 
   24176             : static PyGetSetDef py_DNS_RPC_FORWARDERS_W2K_getsetters[] = {
   24177             :         {
   24178             :                 .name = discard_const_p(char, "fRecurseAfterForwarding"),
   24179             :                 .get = py_DNS_RPC_FORWARDERS_W2K_get_fRecurseAfterForwarding,
   24180             :                 .set = py_DNS_RPC_FORWARDERS_W2K_set_fRecurseAfterForwarding,
   24181             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   24182             :         },
   24183             :         {
   24184             :                 .name = discard_const_p(char, "dwForwardTimeout"),
   24185             :                 .get = py_DNS_RPC_FORWARDERS_W2K_get_dwForwardTimeout,
   24186             :                 .set = py_DNS_RPC_FORWARDERS_W2K_set_dwForwardTimeout,
   24187             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   24188             :         },
   24189             :         {
   24190             :                 .name = discard_const_p(char, "aipForwarders"),
   24191             :                 .get = py_DNS_RPC_FORWARDERS_W2K_get_aipForwarders,
   24192             :                 .set = py_DNS_RPC_FORWARDERS_W2K_set_aipForwarders,
   24193             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
   24194             :         },
   24195             :         { .name = NULL }
   24196             : };
   24197             : 
   24198           0 : static PyObject *py_DNS_RPC_FORWARDERS_W2K_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   24199             : {
   24200           0 :         return pytalloc_new(struct DNS_RPC_FORWARDERS_W2K, type);
   24201             : }
   24202             : 
   24203             : 
   24204             : static PyTypeObject DNS_RPC_FORWARDERS_W2K_Type = {
   24205             :         PyVarObject_HEAD_INIT(NULL, 0)
   24206             :         .tp_name = "dnsserver.DNS_RPC_FORWARDERS_W2K",
   24207             :         .tp_getset = py_DNS_RPC_FORWARDERS_W2K_getsetters,
   24208             :         .tp_methods = NULL,
   24209             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   24210             :         .tp_new = py_DNS_RPC_FORWARDERS_W2K_new,
   24211             : };
   24212             : 
   24213             : 
   24214           0 : static PyObject *py_DNS_RPC_FORWARDERS_DOTNET_get_dwRpcStructureVersion(PyObject *obj, void *closure)
   24215             : {
   24216           0 :         struct DNS_RPC_FORWARDERS_DOTNET *object = pytalloc_get_ptr(obj);
   24217           0 :         PyObject *py_dwRpcStructureVersion;
   24218           0 :         py_dwRpcStructureVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcStructureVersion));
   24219           0 :         return py_dwRpcStructureVersion;
   24220             : }
   24221             : 
   24222           0 : static int py_DNS_RPC_FORWARDERS_DOTNET_set_dwRpcStructureVersion(PyObject *py_obj, PyObject *value, void *closure)
   24223             : {
   24224           0 :         struct DNS_RPC_FORWARDERS_DOTNET *object = pytalloc_get_ptr(py_obj);
   24225           0 :         if (value == NULL) {
   24226           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcStructureVersion");
   24227           0 :                 return -1;
   24228             :         }
   24229             :         {
   24230           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcStructureVersion));
   24231           0 :                 if (PyLong_Check(value)) {
   24232           0 :                         unsigned long long test_var;
   24233           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   24234           0 :                         if (PyErr_Occurred() != NULL) {
   24235           0 :                                 return -1;
   24236             :                         }
   24237           0 :                         if (test_var > uint_max) {
   24238           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   24239             :                                   PyLong_Type.tp_name, uint_max, test_var);
   24240           0 :                                 return -1;
   24241             :                         }
   24242           0 :                         object->dwRpcStructureVersion = test_var;
   24243             :                 } else {
   24244           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   24245             :                           PyLong_Type.tp_name);
   24246           0 :                         return -1;
   24247             :                 }
   24248             :         }
   24249           0 :         return 0;
   24250             : }
   24251             : 
   24252           0 : static PyObject *py_DNS_RPC_FORWARDERS_DOTNET_get_dwReserved0(PyObject *obj, void *closure)
   24253             : {
   24254           0 :         struct DNS_RPC_FORWARDERS_DOTNET *object = pytalloc_get_ptr(obj);
   24255           0 :         PyObject *py_dwReserved0;
   24256           0 :         py_dwReserved0 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved0));
   24257           0 :         return py_dwReserved0;
   24258             : }
   24259             : 
   24260           0 : static int py_DNS_RPC_FORWARDERS_DOTNET_set_dwReserved0(PyObject *py_obj, PyObject *value, void *closure)
   24261             : {
   24262           0 :         struct DNS_RPC_FORWARDERS_DOTNET *object = pytalloc_get_ptr(py_obj);
   24263           0 :         if (value == NULL) {
   24264           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved0");
   24265           0 :                 return -1;
   24266             :         }
   24267             :         {
   24268           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved0));
   24269           0 :                 if (PyLong_Check(value)) {
   24270           0 :                         unsigned long long test_var;
   24271           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   24272           0 :                         if (PyErr_Occurred() != NULL) {
   24273           0 :                                 return -1;
   24274             :                         }
   24275           0 :                         if (test_var > uint_max) {
   24276           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   24277             :                                   PyLong_Type.tp_name, uint_max, test_var);
   24278           0 :                                 return -1;
   24279             :                         }
   24280           0 :                         object->dwReserved0 = test_var;
   24281             :                 } else {
   24282           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   24283             :                           PyLong_Type.tp_name);
   24284           0 :                         return -1;
   24285             :                 }
   24286             :         }
   24287           0 :         return 0;
   24288             : }
   24289             : 
   24290           0 : static PyObject *py_DNS_RPC_FORWARDERS_DOTNET_get_fRecurseAfterForwarding(PyObject *obj, void *closure)
   24291             : {
   24292           0 :         struct DNS_RPC_FORWARDERS_DOTNET *object = pytalloc_get_ptr(obj);
   24293           0 :         PyObject *py_fRecurseAfterForwarding;
   24294           0 :         py_fRecurseAfterForwarding = PyLong_FromUnsignedLongLong((uint32_t)(object->fRecurseAfterForwarding));
   24295           0 :         return py_fRecurseAfterForwarding;
   24296             : }
   24297             : 
   24298           0 : static int py_DNS_RPC_FORWARDERS_DOTNET_set_fRecurseAfterForwarding(PyObject *py_obj, PyObject *value, void *closure)
   24299             : {
   24300           0 :         struct DNS_RPC_FORWARDERS_DOTNET *object = pytalloc_get_ptr(py_obj);
   24301           0 :         if (value == NULL) {
   24302           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fRecurseAfterForwarding");
   24303           0 :                 return -1;
   24304             :         }
   24305             :         {
   24306           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fRecurseAfterForwarding));
   24307           0 :                 if (PyLong_Check(value)) {
   24308           0 :                         unsigned long long test_var;
   24309           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   24310           0 :                         if (PyErr_Occurred() != NULL) {
   24311           0 :                                 return -1;
   24312             :                         }
   24313           0 :                         if (test_var > uint_max) {
   24314           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   24315             :                                   PyLong_Type.tp_name, uint_max, test_var);
   24316           0 :                                 return -1;
   24317             :                         }
   24318           0 :                         object->fRecurseAfterForwarding = test_var;
   24319             :                 } else {
   24320           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   24321             :                           PyLong_Type.tp_name);
   24322           0 :                         return -1;
   24323             :                 }
   24324             :         }
   24325           0 :         return 0;
   24326             : }
   24327             : 
   24328           0 : static PyObject *py_DNS_RPC_FORWARDERS_DOTNET_get_dwForwardTimeout(PyObject *obj, void *closure)
   24329             : {
   24330           0 :         struct DNS_RPC_FORWARDERS_DOTNET *object = pytalloc_get_ptr(obj);
   24331           0 :         PyObject *py_dwForwardTimeout;
   24332           0 :         py_dwForwardTimeout = PyLong_FromUnsignedLongLong((uint32_t)(object->dwForwardTimeout));
   24333           0 :         return py_dwForwardTimeout;
   24334             : }
   24335             : 
   24336           0 : static int py_DNS_RPC_FORWARDERS_DOTNET_set_dwForwardTimeout(PyObject *py_obj, PyObject *value, void *closure)
   24337             : {
   24338           0 :         struct DNS_RPC_FORWARDERS_DOTNET *object = pytalloc_get_ptr(py_obj);
   24339           0 :         if (value == NULL) {
   24340           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwForwardTimeout");
   24341           0 :                 return -1;
   24342             :         }
   24343             :         {
   24344           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwForwardTimeout));
   24345           0 :                 if (PyLong_Check(value)) {
   24346           0 :                         unsigned long long test_var;
   24347           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   24348           0 :                         if (PyErr_Occurred() != NULL) {
   24349           0 :                                 return -1;
   24350             :                         }
   24351           0 :                         if (test_var > uint_max) {
   24352           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   24353             :                                   PyLong_Type.tp_name, uint_max, test_var);
   24354           0 :                                 return -1;
   24355             :                         }
   24356           0 :                         object->dwForwardTimeout = test_var;
   24357             :                 } else {
   24358           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   24359             :                           PyLong_Type.tp_name);
   24360           0 :                         return -1;
   24361             :                 }
   24362             :         }
   24363           0 :         return 0;
   24364             : }
   24365             : 
   24366           0 : static PyObject *py_DNS_RPC_FORWARDERS_DOTNET_get_aipForwarders(PyObject *obj, void *closure)
   24367             : {
   24368           0 :         struct DNS_RPC_FORWARDERS_DOTNET *object = pytalloc_get_ptr(obj);
   24369           0 :         PyObject *py_aipForwarders;
   24370           0 :         if (object->aipForwarders == NULL) {
   24371           0 :                 Py_RETURN_NONE;
   24372             :         }
   24373           0 :         if (object->aipForwarders == NULL) {
   24374           0 :                 py_aipForwarders = Py_None;
   24375           0 :                 Py_INCREF(py_aipForwarders);
   24376             :         } else {
   24377           0 :                 py_aipForwarders = pytalloc_reference_ex(&IP4_ARRAY_Type, object->aipForwarders, object->aipForwarders);
   24378             :         }
   24379           0 :         return py_aipForwarders;
   24380             : }
   24381             : 
   24382           0 : static int py_DNS_RPC_FORWARDERS_DOTNET_set_aipForwarders(PyObject *py_obj, PyObject *value, void *closure)
   24383             : {
   24384           0 :         struct DNS_RPC_FORWARDERS_DOTNET *object = pytalloc_get_ptr(py_obj);
   24385           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipForwarders));
   24386           0 :         if (value == NULL) {
   24387           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipForwarders");
   24388           0 :                 return -1;
   24389             :         }
   24390           0 :         if (value == Py_None) {
   24391           0 :                 object->aipForwarders = NULL;
   24392             :         } else {
   24393           0 :                 object->aipForwarders = NULL;
   24394           0 :                 PY_CHECK_TYPE(&IP4_ARRAY_Type, value, return -1;);
   24395           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   24396           0 :                         PyErr_NoMemory();
   24397           0 :                         return -1;
   24398             :                 }
   24399           0 :                 object->aipForwarders = (struct IP4_ARRAY *)pytalloc_get_ptr(value);
   24400             :         }
   24401           0 :         return 0;
   24402             : }
   24403             : 
   24404             : static PyGetSetDef py_DNS_RPC_FORWARDERS_DOTNET_getsetters[] = {
   24405             :         {
   24406             :                 .name = discard_const_p(char, "dwRpcStructureVersion"),
   24407             :                 .get = py_DNS_RPC_FORWARDERS_DOTNET_get_dwRpcStructureVersion,
   24408             :                 .set = py_DNS_RPC_FORWARDERS_DOTNET_set_dwRpcStructureVersion,
   24409             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   24410             :         },
   24411             :         {
   24412             :                 .name = discard_const_p(char, "dwReserved0"),
   24413             :                 .get = py_DNS_RPC_FORWARDERS_DOTNET_get_dwReserved0,
   24414             :                 .set = py_DNS_RPC_FORWARDERS_DOTNET_set_dwReserved0,
   24415             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   24416             :         },
   24417             :         {
   24418             :                 .name = discard_const_p(char, "fRecurseAfterForwarding"),
   24419             :                 .get = py_DNS_RPC_FORWARDERS_DOTNET_get_fRecurseAfterForwarding,
   24420             :                 .set = py_DNS_RPC_FORWARDERS_DOTNET_set_fRecurseAfterForwarding,
   24421             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   24422             :         },
   24423             :         {
   24424             :                 .name = discard_const_p(char, "dwForwardTimeout"),
   24425             :                 .get = py_DNS_RPC_FORWARDERS_DOTNET_get_dwForwardTimeout,
   24426             :                 .set = py_DNS_RPC_FORWARDERS_DOTNET_set_dwForwardTimeout,
   24427             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   24428             :         },
   24429             :         {
   24430             :                 .name = discard_const_p(char, "aipForwarders"),
   24431             :                 .get = py_DNS_RPC_FORWARDERS_DOTNET_get_aipForwarders,
   24432             :                 .set = py_DNS_RPC_FORWARDERS_DOTNET_set_aipForwarders,
   24433             :                 .doc = discard_const_p(char, "PIDL-generated element of base type IP4_ARRAY")
   24434             :         },
   24435             :         { .name = NULL }
   24436             : };
   24437             : 
   24438           0 : static PyObject *py_DNS_RPC_FORWARDERS_DOTNET_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   24439             : {
   24440           0 :         return pytalloc_new(struct DNS_RPC_FORWARDERS_DOTNET, type);
   24441             : }
   24442             : 
   24443             : 
   24444             : static PyTypeObject DNS_RPC_FORWARDERS_DOTNET_Type = {
   24445             :         PyVarObject_HEAD_INIT(NULL, 0)
   24446             :         .tp_name = "dnsserver.DNS_RPC_FORWARDERS_DOTNET",
   24447             :         .tp_getset = py_DNS_RPC_FORWARDERS_DOTNET_getsetters,
   24448             :         .tp_methods = NULL,
   24449             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   24450             :         .tp_new = py_DNS_RPC_FORWARDERS_DOTNET_new,
   24451             : };
   24452             : 
   24453             : 
   24454           0 : static PyObject *py_DNS_RPC_FORWARDERS_LONGHORN_get_dwRpcStructureVersion(PyObject *obj, void *closure)
   24455             : {
   24456           0 :         struct DNS_RPC_FORWARDERS_LONGHORN *object = pytalloc_get_ptr(obj);
   24457           0 :         PyObject *py_dwRpcStructureVersion;
   24458           0 :         py_dwRpcStructureVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcStructureVersion));
   24459           0 :         return py_dwRpcStructureVersion;
   24460             : }
   24461             : 
   24462           0 : static int py_DNS_RPC_FORWARDERS_LONGHORN_set_dwRpcStructureVersion(PyObject *py_obj, PyObject *value, void *closure)
   24463             : {
   24464           0 :         struct DNS_RPC_FORWARDERS_LONGHORN *object = pytalloc_get_ptr(py_obj);
   24465           0 :         if (value == NULL) {
   24466           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcStructureVersion");
   24467           0 :                 return -1;
   24468             :         }
   24469             :         {
   24470           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcStructureVersion));
   24471           0 :                 if (PyLong_Check(value)) {
   24472           0 :                         unsigned long long test_var;
   24473           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   24474           0 :                         if (PyErr_Occurred() != NULL) {
   24475           0 :                                 return -1;
   24476             :                         }
   24477           0 :                         if (test_var > uint_max) {
   24478           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   24479             :                                   PyLong_Type.tp_name, uint_max, test_var);
   24480           0 :                                 return -1;
   24481             :                         }
   24482           0 :                         object->dwRpcStructureVersion = test_var;
   24483             :                 } else {
   24484           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   24485             :                           PyLong_Type.tp_name);
   24486           0 :                         return -1;
   24487             :                 }
   24488             :         }
   24489           0 :         return 0;
   24490             : }
   24491             : 
   24492           0 : static PyObject *py_DNS_RPC_FORWARDERS_LONGHORN_get_dwReserved0(PyObject *obj, void *closure)
   24493             : {
   24494           0 :         struct DNS_RPC_FORWARDERS_LONGHORN *object = pytalloc_get_ptr(obj);
   24495           0 :         PyObject *py_dwReserved0;
   24496           0 :         py_dwReserved0 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved0));
   24497           0 :         return py_dwReserved0;
   24498             : }
   24499             : 
   24500           0 : static int py_DNS_RPC_FORWARDERS_LONGHORN_set_dwReserved0(PyObject *py_obj, PyObject *value, void *closure)
   24501             : {
   24502           0 :         struct DNS_RPC_FORWARDERS_LONGHORN *object = pytalloc_get_ptr(py_obj);
   24503           0 :         if (value == NULL) {
   24504           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved0");
   24505           0 :                 return -1;
   24506             :         }
   24507             :         {
   24508           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved0));
   24509           0 :                 if (PyLong_Check(value)) {
   24510           0 :                         unsigned long long test_var;
   24511           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   24512           0 :                         if (PyErr_Occurred() != NULL) {
   24513           0 :                                 return -1;
   24514             :                         }
   24515           0 :                         if (test_var > uint_max) {
   24516           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   24517             :                                   PyLong_Type.tp_name, uint_max, test_var);
   24518           0 :                                 return -1;
   24519             :                         }
   24520           0 :                         object->dwReserved0 = test_var;
   24521             :                 } else {
   24522           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   24523             :                           PyLong_Type.tp_name);
   24524           0 :                         return -1;
   24525             :                 }
   24526             :         }
   24527           0 :         return 0;
   24528             : }
   24529             : 
   24530           0 : static PyObject *py_DNS_RPC_FORWARDERS_LONGHORN_get_fRecurseAfterForwarding(PyObject *obj, void *closure)
   24531             : {
   24532           0 :         struct DNS_RPC_FORWARDERS_LONGHORN *object = pytalloc_get_ptr(obj);
   24533           0 :         PyObject *py_fRecurseAfterForwarding;
   24534           0 :         py_fRecurseAfterForwarding = PyLong_FromUnsignedLongLong((uint32_t)(object->fRecurseAfterForwarding));
   24535           0 :         return py_fRecurseAfterForwarding;
   24536             : }
   24537             : 
   24538           0 : static int py_DNS_RPC_FORWARDERS_LONGHORN_set_fRecurseAfterForwarding(PyObject *py_obj, PyObject *value, void *closure)
   24539             : {
   24540           0 :         struct DNS_RPC_FORWARDERS_LONGHORN *object = pytalloc_get_ptr(py_obj);
   24541           0 :         if (value == NULL) {
   24542           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fRecurseAfterForwarding");
   24543           0 :                 return -1;
   24544             :         }
   24545             :         {
   24546           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fRecurseAfterForwarding));
   24547           0 :                 if (PyLong_Check(value)) {
   24548           0 :                         unsigned long long test_var;
   24549           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   24550           0 :                         if (PyErr_Occurred() != NULL) {
   24551           0 :                                 return -1;
   24552             :                         }
   24553           0 :                         if (test_var > uint_max) {
   24554           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   24555             :                                   PyLong_Type.tp_name, uint_max, test_var);
   24556           0 :                                 return -1;
   24557             :                         }
   24558           0 :                         object->fRecurseAfterForwarding = test_var;
   24559             :                 } else {
   24560           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   24561             :                           PyLong_Type.tp_name);
   24562           0 :                         return -1;
   24563             :                 }
   24564             :         }
   24565           0 :         return 0;
   24566             : }
   24567             : 
   24568           0 : static PyObject *py_DNS_RPC_FORWARDERS_LONGHORN_get_dwForwardTimeout(PyObject *obj, void *closure)
   24569             : {
   24570           0 :         struct DNS_RPC_FORWARDERS_LONGHORN *object = pytalloc_get_ptr(obj);
   24571           0 :         PyObject *py_dwForwardTimeout;
   24572           0 :         py_dwForwardTimeout = PyLong_FromUnsignedLongLong((uint32_t)(object->dwForwardTimeout));
   24573           0 :         return py_dwForwardTimeout;
   24574             : }
   24575             : 
   24576           0 : static int py_DNS_RPC_FORWARDERS_LONGHORN_set_dwForwardTimeout(PyObject *py_obj, PyObject *value, void *closure)
   24577             : {
   24578           0 :         struct DNS_RPC_FORWARDERS_LONGHORN *object = pytalloc_get_ptr(py_obj);
   24579           0 :         if (value == NULL) {
   24580           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwForwardTimeout");
   24581           0 :                 return -1;
   24582             :         }
   24583             :         {
   24584           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwForwardTimeout));
   24585           0 :                 if (PyLong_Check(value)) {
   24586           0 :                         unsigned long long test_var;
   24587           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   24588           0 :                         if (PyErr_Occurred() != NULL) {
   24589           0 :                                 return -1;
   24590             :                         }
   24591           0 :                         if (test_var > uint_max) {
   24592           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   24593             :                                   PyLong_Type.tp_name, uint_max, test_var);
   24594           0 :                                 return -1;
   24595             :                         }
   24596           0 :                         object->dwForwardTimeout = test_var;
   24597             :                 } else {
   24598           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   24599             :                           PyLong_Type.tp_name);
   24600           0 :                         return -1;
   24601             :                 }
   24602             :         }
   24603           0 :         return 0;
   24604             : }
   24605             : 
   24606           0 : static PyObject *py_DNS_RPC_FORWARDERS_LONGHORN_get_aipForwarders(PyObject *obj, void *closure)
   24607             : {
   24608           0 :         struct DNS_RPC_FORWARDERS_LONGHORN *object = pytalloc_get_ptr(obj);
   24609           0 :         PyObject *py_aipForwarders;
   24610           0 :         if (object->aipForwarders == NULL) {
   24611           0 :                 Py_RETURN_NONE;
   24612             :         }
   24613           0 :         if (object->aipForwarders == NULL) {
   24614           0 :                 py_aipForwarders = Py_None;
   24615           0 :                 Py_INCREF(py_aipForwarders);
   24616             :         } else {
   24617           0 :                 py_aipForwarders = pytalloc_reference_ex(&DNS_ADDR_ARRAY_Type, object->aipForwarders, object->aipForwarders);
   24618             :         }
   24619           0 :         return py_aipForwarders;
   24620             : }
   24621             : 
   24622           0 : static int py_DNS_RPC_FORWARDERS_LONGHORN_set_aipForwarders(PyObject *py_obj, PyObject *value, void *closure)
   24623             : {
   24624           0 :         struct DNS_RPC_FORWARDERS_LONGHORN *object = pytalloc_get_ptr(py_obj);
   24625           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->aipForwarders));
   24626           0 :         if (value == NULL) {
   24627           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->aipForwarders");
   24628           0 :                 return -1;
   24629             :         }
   24630           0 :         if (value == Py_None) {
   24631           0 :                 object->aipForwarders = NULL;
   24632             :         } else {
   24633           0 :                 object->aipForwarders = NULL;
   24634           0 :                 PY_CHECK_TYPE(&DNS_ADDR_ARRAY_Type, value, return -1;);
   24635           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   24636           0 :                         PyErr_NoMemory();
   24637           0 :                         return -1;
   24638             :                 }
   24639           0 :                 object->aipForwarders = (struct DNS_ADDR_ARRAY *)pytalloc_get_ptr(value);
   24640             :         }
   24641           0 :         return 0;
   24642             : }
   24643             : 
   24644             : static PyGetSetDef py_DNS_RPC_FORWARDERS_LONGHORN_getsetters[] = {
   24645             :         {
   24646             :                 .name = discard_const_p(char, "dwRpcStructureVersion"),
   24647             :                 .get = py_DNS_RPC_FORWARDERS_LONGHORN_get_dwRpcStructureVersion,
   24648             :                 .set = py_DNS_RPC_FORWARDERS_LONGHORN_set_dwRpcStructureVersion,
   24649             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   24650             :         },
   24651             :         {
   24652             :                 .name = discard_const_p(char, "dwReserved0"),
   24653             :                 .get = py_DNS_RPC_FORWARDERS_LONGHORN_get_dwReserved0,
   24654             :                 .set = py_DNS_RPC_FORWARDERS_LONGHORN_set_dwReserved0,
   24655             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   24656             :         },
   24657             :         {
   24658             :                 .name = discard_const_p(char, "fRecurseAfterForwarding"),
   24659             :                 .get = py_DNS_RPC_FORWARDERS_LONGHORN_get_fRecurseAfterForwarding,
   24660             :                 .set = py_DNS_RPC_FORWARDERS_LONGHORN_set_fRecurseAfterForwarding,
   24661             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   24662             :         },
   24663             :         {
   24664             :                 .name = discard_const_p(char, "dwForwardTimeout"),
   24665             :                 .get = py_DNS_RPC_FORWARDERS_LONGHORN_get_dwForwardTimeout,
   24666             :                 .set = py_DNS_RPC_FORWARDERS_LONGHORN_set_dwForwardTimeout,
   24667             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   24668             :         },
   24669             :         {
   24670             :                 .name = discard_const_p(char, "aipForwarders"),
   24671             :                 .get = py_DNS_RPC_FORWARDERS_LONGHORN_get_aipForwarders,
   24672             :                 .set = py_DNS_RPC_FORWARDERS_LONGHORN_set_aipForwarders,
   24673             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_ADDR_ARRAY")
   24674             :         },
   24675             :         { .name = NULL }
   24676             : };
   24677             : 
   24678           0 : static PyObject *py_DNS_RPC_FORWARDERS_LONGHORN_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   24679             : {
   24680           0 :         return pytalloc_new(struct DNS_RPC_FORWARDERS_LONGHORN, type);
   24681             : }
   24682             : 
   24683             : 
   24684             : static PyTypeObject DNS_RPC_FORWARDERS_LONGHORN_Type = {
   24685             :         PyVarObject_HEAD_INIT(NULL, 0)
   24686             :         .tp_name = "dnsserver.DNS_RPC_FORWARDERS_LONGHORN",
   24687             :         .tp_getset = py_DNS_RPC_FORWARDERS_LONGHORN_getsetters,
   24688             :         .tp_methods = NULL,
   24689             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   24690             :         .tp_new = py_DNS_RPC_FORWARDERS_LONGHORN_new,
   24691             : };
   24692             : 
   24693             : 
   24694           0 : static PyObject *py_DNS_RPC_AUTOCONFIGURE_get_dwRpcStructureVersion(PyObject *obj, void *closure)
   24695             : {
   24696           0 :         struct DNS_RPC_AUTOCONFIGURE *object = pytalloc_get_ptr(obj);
   24697           0 :         PyObject *py_dwRpcStructureVersion;
   24698           0 :         py_dwRpcStructureVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->dwRpcStructureVersion));
   24699           0 :         return py_dwRpcStructureVersion;
   24700             : }
   24701             : 
   24702           0 : static int py_DNS_RPC_AUTOCONFIGURE_set_dwRpcStructureVersion(PyObject *py_obj, PyObject *value, void *closure)
   24703             : {
   24704           0 :         struct DNS_RPC_AUTOCONFIGURE *object = pytalloc_get_ptr(py_obj);
   24705           0 :         if (value == NULL) {
   24706           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwRpcStructureVersion");
   24707           0 :                 return -1;
   24708             :         }
   24709             :         {
   24710           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwRpcStructureVersion));
   24711           0 :                 if (PyLong_Check(value)) {
   24712           0 :                         unsigned long long test_var;
   24713           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   24714           0 :                         if (PyErr_Occurred() != NULL) {
   24715           0 :                                 return -1;
   24716             :                         }
   24717           0 :                         if (test_var > uint_max) {
   24718           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   24719             :                                   PyLong_Type.tp_name, uint_max, test_var);
   24720           0 :                                 return -1;
   24721             :                         }
   24722           0 :                         object->dwRpcStructureVersion = test_var;
   24723             :                 } else {
   24724           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   24725             :                           PyLong_Type.tp_name);
   24726           0 :                         return -1;
   24727             :                 }
   24728             :         }
   24729           0 :         return 0;
   24730             : }
   24731             : 
   24732           0 : static PyObject *py_DNS_RPC_AUTOCONFIGURE_get_dwReserved0(PyObject *obj, void *closure)
   24733             : {
   24734           0 :         struct DNS_RPC_AUTOCONFIGURE *object = pytalloc_get_ptr(obj);
   24735           0 :         PyObject *py_dwReserved0;
   24736           0 :         py_dwReserved0 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved0));
   24737           0 :         return py_dwReserved0;
   24738             : }
   24739             : 
   24740           0 : static int py_DNS_RPC_AUTOCONFIGURE_set_dwReserved0(PyObject *py_obj, PyObject *value, void *closure)
   24741             : {
   24742           0 :         struct DNS_RPC_AUTOCONFIGURE *object = pytalloc_get_ptr(py_obj);
   24743           0 :         if (value == NULL) {
   24744           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved0");
   24745           0 :                 return -1;
   24746             :         }
   24747             :         {
   24748           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved0));
   24749           0 :                 if (PyLong_Check(value)) {
   24750           0 :                         unsigned long long test_var;
   24751           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   24752           0 :                         if (PyErr_Occurred() != NULL) {
   24753           0 :                                 return -1;
   24754             :                         }
   24755           0 :                         if (test_var > uint_max) {
   24756           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   24757             :                                   PyLong_Type.tp_name, uint_max, test_var);
   24758           0 :                                 return -1;
   24759             :                         }
   24760           0 :                         object->dwReserved0 = test_var;
   24761             :                 } else {
   24762           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   24763             :                           PyLong_Type.tp_name);
   24764           0 :                         return -1;
   24765             :                 }
   24766             :         }
   24767           0 :         return 0;
   24768             : }
   24769             : 
   24770           0 : static PyObject *py_DNS_RPC_AUTOCONFIGURE_get_dwAutoConfigFlags(PyObject *obj, void *closure)
   24771             : {
   24772           0 :         struct DNS_RPC_AUTOCONFIGURE *object = pytalloc_get_ptr(obj);
   24773           0 :         PyObject *py_dwAutoConfigFlags;
   24774           0 :         py_dwAutoConfigFlags = PyLong_FromUnsignedLongLong((uint32_t)(object->dwAutoConfigFlags));
   24775           0 :         return py_dwAutoConfigFlags;
   24776             : }
   24777             : 
   24778           0 : static int py_DNS_RPC_AUTOCONFIGURE_set_dwAutoConfigFlags(PyObject *py_obj, PyObject *value, void *closure)
   24779             : {
   24780           0 :         struct DNS_RPC_AUTOCONFIGURE *object = pytalloc_get_ptr(py_obj);
   24781           0 :         if (value == NULL) {
   24782           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwAutoConfigFlags");
   24783           0 :                 return -1;
   24784             :         }
   24785             :         {
   24786           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwAutoConfigFlags));
   24787           0 :                 if (PyLong_Check(value)) {
   24788           0 :                         unsigned long long test_var;
   24789           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   24790           0 :                         if (PyErr_Occurred() != NULL) {
   24791           0 :                                 return -1;
   24792             :                         }
   24793           0 :                         if (test_var > uint_max) {
   24794           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   24795             :                                   PyLong_Type.tp_name, uint_max, test_var);
   24796           0 :                                 return -1;
   24797             :                         }
   24798           0 :                         object->dwAutoConfigFlags = test_var;
   24799             :                 } else {
   24800           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   24801             :                           PyLong_Type.tp_name);
   24802           0 :                         return -1;
   24803             :                 }
   24804             :         }
   24805           0 :         return 0;
   24806             : }
   24807             : 
   24808           0 : static PyObject *py_DNS_RPC_AUTOCONFIGURE_get_dwReserved1(PyObject *obj, void *closure)
   24809             : {
   24810           0 :         struct DNS_RPC_AUTOCONFIGURE *object = pytalloc_get_ptr(obj);
   24811           0 :         PyObject *py_dwReserved1;
   24812           0 :         py_dwReserved1 = PyLong_FromUnsignedLongLong((uint32_t)(object->dwReserved1));
   24813           0 :         return py_dwReserved1;
   24814             : }
   24815             : 
   24816           0 : static int py_DNS_RPC_AUTOCONFIGURE_set_dwReserved1(PyObject *py_obj, PyObject *value, void *closure)
   24817             : {
   24818           0 :         struct DNS_RPC_AUTOCONFIGURE *object = pytalloc_get_ptr(py_obj);
   24819           0 :         if (value == NULL) {
   24820           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwReserved1");
   24821           0 :                 return -1;
   24822             :         }
   24823             :         {
   24824           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwReserved1));
   24825           0 :                 if (PyLong_Check(value)) {
   24826           0 :                         unsigned long long test_var;
   24827           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   24828           0 :                         if (PyErr_Occurred() != NULL) {
   24829           0 :                                 return -1;
   24830             :                         }
   24831           0 :                         if (test_var > uint_max) {
   24832           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   24833             :                                   PyLong_Type.tp_name, uint_max, test_var);
   24834           0 :                                 return -1;
   24835             :                         }
   24836           0 :                         object->dwReserved1 = test_var;
   24837             :                 } else {
   24838           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   24839             :                           PyLong_Type.tp_name);
   24840           0 :                         return -1;
   24841             :                 }
   24842             :         }
   24843           0 :         return 0;
   24844             : }
   24845             : 
   24846           0 : static PyObject *py_DNS_RPC_AUTOCONFIGURE_get_pszNewDomainName(PyObject *obj, void *closure)
   24847             : {
   24848           0 :         struct DNS_RPC_AUTOCONFIGURE *object = pytalloc_get_ptr(obj);
   24849           0 :         PyObject *py_pszNewDomainName;
   24850           0 :         if (object->pszNewDomainName == NULL) {
   24851           0 :                 Py_RETURN_NONE;
   24852             :         }
   24853           0 :         if (object->pszNewDomainName == NULL) {
   24854           0 :                 py_pszNewDomainName = Py_None;
   24855           0 :                 Py_INCREF(py_pszNewDomainName);
   24856             :         } else {
   24857           0 :                 if (object->pszNewDomainName == NULL) {
   24858           0 :                         py_pszNewDomainName = Py_None;
   24859           0 :                         Py_INCREF(py_pszNewDomainName);
   24860             :                 } else {
   24861           0 :                         py_pszNewDomainName = PyUnicode_Decode(object->pszNewDomainName, strlen(object->pszNewDomainName), "utf-8", "ignore");
   24862             :                 }
   24863             :         }
   24864           0 :         return py_pszNewDomainName;
   24865             : }
   24866             : 
   24867           0 : static int py_DNS_RPC_AUTOCONFIGURE_set_pszNewDomainName(PyObject *py_obj, PyObject *value, void *closure)
   24868             : {
   24869           0 :         struct DNS_RPC_AUTOCONFIGURE *object = pytalloc_get_ptr(py_obj);
   24870           0 :         if (value == NULL) {
   24871           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->pszNewDomainName");
   24872           0 :                 return -1;
   24873             :         }
   24874           0 :         if (value == Py_None) {
   24875           0 :                 object->pszNewDomainName = NULL;
   24876             :         } else {
   24877           0 :                 object->pszNewDomainName = NULL;
   24878             :                 {
   24879           0 :                         const char *test_str;
   24880           0 :                         const char *talloc_str;
   24881           0 :                         PyObject *unicode = NULL;
   24882           0 :                         if (PyUnicode_Check(value)) {
   24883           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   24884           0 :                                 if (unicode == NULL) {
   24885           0 :                                         return -1;
   24886             :                                 }
   24887           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   24888           0 :                         } else if (PyBytes_Check(value)) {
   24889           0 :                                 test_str = PyBytes_AS_STRING(value);
   24890             :                         } else {
   24891           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   24892           0 :                                 return -1;
   24893             :                         }
   24894           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   24895           0 :                         if (unicode != NULL) {
   24896           0 :                                 Py_DECREF(unicode);
   24897             :                         }
   24898           0 :                         if (talloc_str == NULL) {
   24899           0 :                                 PyErr_NoMemory();
   24900           0 :                                 return -1;
   24901             :                         }
   24902           0 :                         object->pszNewDomainName = talloc_str;
   24903             :                 }
   24904             :         }
   24905           0 :         return 0;
   24906             : }
   24907             : 
   24908             : static PyGetSetDef py_DNS_RPC_AUTOCONFIGURE_getsetters[] = {
   24909             :         {
   24910             :                 .name = discard_const_p(char, "dwRpcStructureVersion"),
   24911             :                 .get = py_DNS_RPC_AUTOCONFIGURE_get_dwRpcStructureVersion,
   24912             :                 .set = py_DNS_RPC_AUTOCONFIGURE_set_dwRpcStructureVersion,
   24913             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   24914             :         },
   24915             :         {
   24916             :                 .name = discard_const_p(char, "dwReserved0"),
   24917             :                 .get = py_DNS_RPC_AUTOCONFIGURE_get_dwReserved0,
   24918             :                 .set = py_DNS_RPC_AUTOCONFIGURE_set_dwReserved0,
   24919             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   24920             :         },
   24921             :         {
   24922             :                 .name = discard_const_p(char, "dwAutoConfigFlags"),
   24923             :                 .get = py_DNS_RPC_AUTOCONFIGURE_get_dwAutoConfigFlags,
   24924             :                 .set = py_DNS_RPC_AUTOCONFIGURE_set_dwAutoConfigFlags,
   24925             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_AUTOCONFIG")
   24926             :         },
   24927             :         {
   24928             :                 .name = discard_const_p(char, "dwReserved1"),
   24929             :                 .get = py_DNS_RPC_AUTOCONFIGURE_get_dwReserved1,
   24930             :                 .set = py_DNS_RPC_AUTOCONFIGURE_set_dwReserved1,
   24931             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   24932             :         },
   24933             :         {
   24934             :                 .name = discard_const_p(char, "pszNewDomainName"),
   24935             :                 .get = py_DNS_RPC_AUTOCONFIGURE_get_pszNewDomainName,
   24936             :                 .set = py_DNS_RPC_AUTOCONFIGURE_set_pszNewDomainName,
   24937             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   24938             :         },
   24939             :         { .name = NULL }
   24940             : };
   24941             : 
   24942           0 : static PyObject *py_DNS_RPC_AUTOCONFIGURE_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   24943             : {
   24944           0 :         return pytalloc_new(struct DNS_RPC_AUTOCONFIGURE, type);
   24945             : }
   24946             : 
   24947             : 
   24948             : static PyTypeObject DNS_RPC_AUTOCONFIGURE_Type = {
   24949             :         PyVarObject_HEAD_INIT(NULL, 0)
   24950             :         .tp_name = "dnsserver.DNS_RPC_AUTOCONFIGURE",
   24951             :         .tp_getset = py_DNS_RPC_AUTOCONFIGURE_getsetters,
   24952             :         .tp_methods = NULL,
   24953             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   24954             :         .tp_new = py_DNS_RPC_AUTOCONFIGURE_new,
   24955             : };
   24956             : 
   24957             : 
   24958           0 : static PyObject *py_DNSSRV_STAT_HEADER_get_StatId(PyObject *obj, void *closure)
   24959             : {
   24960           0 :         struct DNSSRV_STAT_HEADER *object = pytalloc_get_ptr(obj);
   24961           0 :         PyObject *py_StatId;
   24962           0 :         py_StatId = PyLong_FromUnsignedLongLong((uint32_t)(object->StatId));
   24963           0 :         return py_StatId;
   24964             : }
   24965             : 
   24966           0 : static int py_DNSSRV_STAT_HEADER_set_StatId(PyObject *py_obj, PyObject *value, void *closure)
   24967             : {
   24968           0 :         struct DNSSRV_STAT_HEADER *object = pytalloc_get_ptr(py_obj);
   24969           0 :         if (value == NULL) {
   24970           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->StatId");
   24971           0 :                 return -1;
   24972             :         }
   24973             :         {
   24974           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->StatId));
   24975           0 :                 if (PyLong_Check(value)) {
   24976           0 :                         unsigned long long test_var;
   24977           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   24978           0 :                         if (PyErr_Occurred() != NULL) {
   24979           0 :                                 return -1;
   24980             :                         }
   24981           0 :                         if (test_var > uint_max) {
   24982           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   24983             :                                   PyLong_Type.tp_name, uint_max, test_var);
   24984           0 :                                 return -1;
   24985             :                         }
   24986           0 :                         object->StatId = test_var;
   24987             :                 } else {
   24988           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   24989             :                           PyLong_Type.tp_name);
   24990           0 :                         return -1;
   24991             :                 }
   24992             :         }
   24993           0 :         return 0;
   24994             : }
   24995             : 
   24996           0 : static PyObject *py_DNSSRV_STAT_HEADER_get_wLength(PyObject *obj, void *closure)
   24997             : {
   24998           0 :         struct DNSSRV_STAT_HEADER *object = pytalloc_get_ptr(obj);
   24999           0 :         PyObject *py_wLength;
   25000           0 :         py_wLength = PyLong_FromLong((uint16_t)(object->wLength));
   25001           0 :         return py_wLength;
   25002             : }
   25003             : 
   25004           0 : static int py_DNSSRV_STAT_HEADER_set_wLength(PyObject *py_obj, PyObject *value, void *closure)
   25005             : {
   25006           0 :         struct DNSSRV_STAT_HEADER *object = pytalloc_get_ptr(py_obj);
   25007           0 :         if (value == NULL) {
   25008           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->wLength");
   25009           0 :                 return -1;
   25010             :         }
   25011             :         {
   25012           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->wLength));
   25013           0 :                 if (PyLong_Check(value)) {
   25014           0 :                         unsigned long long test_var;
   25015           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   25016           0 :                         if (PyErr_Occurred() != NULL) {
   25017           0 :                                 return -1;
   25018             :                         }
   25019           0 :                         if (test_var > uint_max) {
   25020           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   25021             :                                   PyLong_Type.tp_name, uint_max, test_var);
   25022           0 :                                 return -1;
   25023             :                         }
   25024           0 :                         object->wLength = test_var;
   25025             :                 } else {
   25026           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   25027             :                           PyLong_Type.tp_name);
   25028           0 :                         return -1;
   25029             :                 }
   25030             :         }
   25031           0 :         return 0;
   25032             : }
   25033             : 
   25034           0 : static PyObject *py_DNSSRV_STAT_HEADER_get_fClear(PyObject *obj, void *closure)
   25035             : {
   25036           0 :         struct DNSSRV_STAT_HEADER *object = pytalloc_get_ptr(obj);
   25037           0 :         PyObject *py_fClear;
   25038           0 :         py_fClear = PyLong_FromLong((uint16_t)(object->fClear));
   25039           0 :         return py_fClear;
   25040             : }
   25041             : 
   25042           0 : static int py_DNSSRV_STAT_HEADER_set_fClear(PyObject *py_obj, PyObject *value, void *closure)
   25043             : {
   25044           0 :         struct DNSSRV_STAT_HEADER *object = pytalloc_get_ptr(py_obj);
   25045           0 :         if (value == NULL) {
   25046           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fClear");
   25047           0 :                 return -1;
   25048             :         }
   25049             :         {
   25050           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fClear));
   25051           0 :                 if (PyLong_Check(value)) {
   25052           0 :                         unsigned long long test_var;
   25053           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   25054           0 :                         if (PyErr_Occurred() != NULL) {
   25055           0 :                                 return -1;
   25056             :                         }
   25057           0 :                         if (test_var > uint_max) {
   25058           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   25059             :                                   PyLong_Type.tp_name, uint_max, test_var);
   25060           0 :                                 return -1;
   25061             :                         }
   25062           0 :                         object->fClear = test_var;
   25063             :                 } else {
   25064           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   25065             :                           PyLong_Type.tp_name);
   25066           0 :                         return -1;
   25067             :                 }
   25068             :         }
   25069           0 :         return 0;
   25070             : }
   25071             : 
   25072           0 : static PyObject *py_DNSSRV_STAT_HEADER_get_fReserved(PyObject *obj, void *closure)
   25073             : {
   25074           0 :         struct DNSSRV_STAT_HEADER *object = pytalloc_get_ptr(obj);
   25075           0 :         PyObject *py_fReserved;
   25076           0 :         py_fReserved = PyLong_FromLong((uint16_t)(object->fReserved));
   25077           0 :         return py_fReserved;
   25078             : }
   25079             : 
   25080           0 : static int py_DNSSRV_STAT_HEADER_set_fReserved(PyObject *py_obj, PyObject *value, void *closure)
   25081             : {
   25082           0 :         struct DNSSRV_STAT_HEADER *object = pytalloc_get_ptr(py_obj);
   25083           0 :         if (value == NULL) {
   25084           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->fReserved");
   25085           0 :                 return -1;
   25086             :         }
   25087             :         {
   25088           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->fReserved));
   25089           0 :                 if (PyLong_Check(value)) {
   25090           0 :                         unsigned long long test_var;
   25091           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   25092           0 :                         if (PyErr_Occurred() != NULL) {
   25093           0 :                                 return -1;
   25094             :                         }
   25095           0 :                         if (test_var > uint_max) {
   25096           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   25097             :                                   PyLong_Type.tp_name, uint_max, test_var);
   25098           0 :                                 return -1;
   25099             :                         }
   25100           0 :                         object->fReserved = test_var;
   25101             :                 } else {
   25102           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   25103             :                           PyLong_Type.tp_name);
   25104           0 :                         return -1;
   25105             :                 }
   25106             :         }
   25107           0 :         return 0;
   25108             : }
   25109             : 
   25110             : static PyGetSetDef py_DNSSRV_STAT_HEADER_getsetters[] = {
   25111             :         {
   25112             :                 .name = discard_const_p(char, "StatId"),
   25113             :                 .get = py_DNSSRV_STAT_HEADER_get_StatId,
   25114             :                 .set = py_DNSSRV_STAT_HEADER_set_StatId,
   25115             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   25116             :         },
   25117             :         {
   25118             :                 .name = discard_const_p(char, "wLength"),
   25119             :                 .get = py_DNSSRV_STAT_HEADER_get_wLength,
   25120             :                 .set = py_DNSSRV_STAT_HEADER_set_wLength,
   25121             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
   25122             :         },
   25123             :         {
   25124             :                 .name = discard_const_p(char, "fClear"),
   25125             :                 .get = py_DNSSRV_STAT_HEADER_get_fClear,
   25126             :                 .set = py_DNSSRV_STAT_HEADER_set_fClear,
   25127             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   25128             :         },
   25129             :         {
   25130             :                 .name = discard_const_p(char, "fReserved"),
   25131             :                 .get = py_DNSSRV_STAT_HEADER_get_fReserved,
   25132             :                 .set = py_DNSSRV_STAT_HEADER_set_fReserved,
   25133             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   25134             :         },
   25135             :         { .name = NULL }
   25136             : };
   25137             : 
   25138           0 : static PyObject *py_DNSSRV_STAT_HEADER_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   25139             : {
   25140           0 :         return pytalloc_new(struct DNSSRV_STAT_HEADER, type);
   25141             : }
   25142             : 
   25143             : 
   25144             : static PyTypeObject DNSSRV_STAT_HEADER_Type = {
   25145             :         PyVarObject_HEAD_INIT(NULL, 0)
   25146             :         .tp_name = "dnsserver.DNSSRV_STAT_HEADER",
   25147             :         .tp_getset = py_DNSSRV_STAT_HEADER_getsetters,
   25148             :         .tp_methods = NULL,
   25149             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   25150             :         .tp_new = py_DNSSRV_STAT_HEADER_new,
   25151             : };
   25152             : 
   25153             : 
   25154           0 : static PyObject *py_DNSSRV_STAT_get_Header(PyObject *obj, void *closure)
   25155             : {
   25156           0 :         struct DNSSRV_STAT *object = pytalloc_get_ptr(obj);
   25157           0 :         PyObject *py_Header;
   25158           0 :         py_Header = pytalloc_reference_ex(&DNSSRV_STAT_HEADER_Type, pytalloc_get_mem_ctx(obj), &object->Header);
   25159           0 :         return py_Header;
   25160             : }
   25161             : 
   25162           0 : static int py_DNSSRV_STAT_set_Header(PyObject *py_obj, PyObject *value, void *closure)
   25163             : {
   25164           0 :         struct DNSSRV_STAT *object = pytalloc_get_ptr(py_obj);
   25165           0 :         if (value == NULL) {
   25166           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->Header");
   25167           0 :                 return -1;
   25168             :         }
   25169           0 :         PY_CHECK_TYPE(&DNSSRV_STAT_HEADER_Type, value, return -1;);
   25170           0 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   25171           0 :                 PyErr_NoMemory();
   25172           0 :                 return -1;
   25173             :         }
   25174           0 :         object->Header = *(struct DNSSRV_STAT_HEADER *)pytalloc_get_ptr(value);
   25175           0 :         return 0;
   25176             : }
   25177             : 
   25178           0 : static PyObject *py_DNSSRV_STAT_get_Buffer(PyObject *obj, void *closure)
   25179             : {
   25180           0 :         struct DNSSRV_STAT *object = pytalloc_get_ptr(obj);
   25181           0 :         PyObject *py_Buffer;
   25182           0 :         py_Buffer = PyList_New(1);
   25183           0 :         if (py_Buffer == NULL) {
   25184           0 :                 return NULL;
   25185             :         }
   25186             :         {
   25187             :                 int Buffer_cntr_0;
   25188           0 :                 for (Buffer_cntr_0 = 0; Buffer_cntr_0 < (1); Buffer_cntr_0++) {
   25189           0 :                         PyObject *py_Buffer_0;
   25190           0 :                         py_Buffer_0 = PyLong_FromLong((uint16_t)((object->Buffer)[Buffer_cntr_0]));
   25191           0 :                         PyList_SetItem(py_Buffer, Buffer_cntr_0, py_Buffer_0);
   25192             :                 }
   25193             :         }
   25194           0 :         return py_Buffer;
   25195             : }
   25196             : 
   25197           0 : static int py_DNSSRV_STAT_set_Buffer(PyObject *py_obj, PyObject *value, void *closure)
   25198             : {
   25199           0 :         struct DNSSRV_STAT *object = pytalloc_get_ptr(py_obj);
   25200           0 :         if (value == NULL) {
   25201           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->Buffer");
   25202           0 :                 return -1;
   25203             :         }
   25204           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
   25205             :         {
   25206           0 :                 int Buffer_cntr_0;
   25207           0 :                 if (ARRAY_SIZE(object->Buffer) != PyList_GET_SIZE(value)) {
   25208           0 :                         PyErr_Format(PyExc_TypeError, "Expected list of type %s, length %zu, got %zd", Py_TYPE(value)->tp_name, ARRAY_SIZE(object->Buffer),  PyList_GET_SIZE(value));
   25209           0 :                         return -1;
   25210             :                 }
   25211           0 :                 for (Buffer_cntr_0 = 0; Buffer_cntr_0 < PyList_GET_SIZE(value); Buffer_cntr_0++) {
   25212           0 :                         if (PyList_GET_ITEM(value, Buffer_cntr_0) == NULL) {
   25213           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->Buffer)[Buffer_cntr_0]");
   25214           0 :                                 return -1;
   25215             :                         }
   25216             :                         {
   25217           0 :                                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof((object->Buffer)[Buffer_cntr_0]));
   25218           0 :                                 if (PyLong_Check(PyList_GET_ITEM(value, Buffer_cntr_0))) {
   25219           0 :                                         unsigned long long test_var;
   25220           0 :                                         test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(value, Buffer_cntr_0));
   25221           0 :                                         if (PyErr_Occurred() != NULL) {
   25222           0 :                                                 return -1;
   25223             :                                         }
   25224           0 :                                         if (test_var > uint_max) {
   25225           0 :                                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   25226             :                                                   PyLong_Type.tp_name, uint_max, test_var);
   25227           0 :                                                 return -1;
   25228             :                                         }
   25229           0 :                                         (object->Buffer)[Buffer_cntr_0] = test_var;
   25230             :                                 } else {
   25231           0 :                                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   25232             :                                           PyLong_Type.tp_name);
   25233           0 :                                         return -1;
   25234             :                                 }
   25235             :                         }
   25236             :                 }
   25237             :         }
   25238           0 :         return 0;
   25239             : }
   25240             : 
   25241             : static PyGetSetDef py_DNSSRV_STAT_getsetters[] = {
   25242             :         {
   25243             :                 .name = discard_const_p(char, "Header"),
   25244             :                 .get = py_DNSSRV_STAT_get_Header,
   25245             :                 .set = py_DNSSRV_STAT_set_Header,
   25246             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNSSRV_STAT_HEADER")
   25247             :         },
   25248             :         {
   25249             :                 .name = discard_const_p(char, "Buffer"),
   25250             :                 .get = py_DNSSRV_STAT_get_Buffer,
   25251             :                 .set = py_DNSSRV_STAT_set_Buffer,
   25252             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   25253             :         },
   25254             :         { .name = NULL }
   25255             : };
   25256             : 
   25257           0 : static PyObject *py_DNSSRV_STAT_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   25258             : {
   25259           0 :         return pytalloc_new(struct DNSSRV_STAT, type);
   25260             : }
   25261             : 
   25262             : 
   25263             : static PyTypeObject DNSSRV_STAT_Type = {
   25264             :         PyVarObject_HEAD_INIT(NULL, 0)
   25265             :         .tp_name = "dnsserver.DNSSRV_STAT",
   25266             :         .tp_getset = py_DNSSRV_STAT_getsetters,
   25267             :         .tp_methods = NULL,
   25268             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   25269             :         .tp_new = py_DNSSRV_STAT_new,
   25270             : };
   25271             : 
   25272          49 : static PyObject *py_import_DNSSRV_RPC_UNION(TALLOC_CTX *mem_ctx, int level, union DNSSRV_RPC_UNION *in)
   25273             : {
   25274           0 :         PyObject *ret;
   25275             : 
   25276          49 :         switch (level) {
   25277           0 :                 case DNSSRV_TYPEID_NULL:
   25278           0 :                         if (in->Null == NULL) {
   25279           0 :                                 ret = Py_None;
   25280           0 :                                 Py_INCREF(ret);
   25281             :                         } else {
   25282           0 :                                 ret = PyLong_FromLong((uint16_t)(*in->Null));
   25283             :                         }
   25284           0 :                         return ret;
   25285             : 
   25286           0 :                 case DNSSRV_TYPEID_DWORD:
   25287           0 :                         ret = PyLong_FromUnsignedLongLong((uint32_t)(in->Dword));
   25288           0 :                         return ret;
   25289             : 
   25290           0 :                 case DNSSRV_TYPEID_LPSTR:
   25291           0 :                         if (in->String == NULL) {
   25292           0 :                                 ret = Py_None;
   25293           0 :                                 Py_INCREF(ret);
   25294             :                         } else {
   25295           0 :                                 if (in->String == NULL) {
   25296           0 :                                         ret = Py_None;
   25297           0 :                                         Py_INCREF(ret);
   25298             :                                 } else {
   25299           0 :                                         ret = PyUnicode_Decode(in->String, strlen(in->String), "utf-8", "ignore");
   25300             :                                 }
   25301             :                         }
   25302           0 :                         return ret;
   25303             : 
   25304           0 :                 case DNSSRV_TYPEID_LPWSTR:
   25305           0 :                         if (in->WideString == NULL) {
   25306           0 :                                 ret = Py_None;
   25307           0 :                                 Py_INCREF(ret);
   25308             :                         } else {
   25309           0 :                                 if (in->WideString == NULL) {
   25310           0 :                                         ret = Py_None;
   25311           0 :                                         Py_INCREF(ret);
   25312             :                                 } else {
   25313           0 :                                         ret = PyUnicode_Decode(in->WideString, strlen(in->WideString), "utf-8", "ignore");
   25314             :                                 }
   25315             :                         }
   25316           0 :                         return ret;
   25317             : 
   25318           0 :                 case DNSSRV_TYPEID_IPARRAY:
   25319           0 :                         if (in->IpArray == NULL) {
   25320           0 :                                 ret = Py_None;
   25321           0 :                                 Py_INCREF(ret);
   25322             :                         } else {
   25323           0 :                                 ret = pytalloc_reference_ex(&IP4_ARRAY_Type, in->IpArray, in->IpArray);
   25324             :                         }
   25325           0 :                         return ret;
   25326             : 
   25327           0 :                 case DNSSRV_TYPEID_BUFFER:
   25328           0 :                         if (in->Buffer == NULL) {
   25329           0 :                                 ret = Py_None;
   25330           0 :                                 Py_INCREF(ret);
   25331             :                         } else {
   25332           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_BUFFER_Type, in->Buffer, in->Buffer);
   25333             :                         }
   25334           0 :                         return ret;
   25335             : 
   25336           4 :                 case DNSSRV_TYPEID_SERVER_INFO_W2K:
   25337           4 :                         if (in->ServerInfoW2K == NULL) {
   25338           0 :                                 ret = Py_None;
   25339           0 :                                 Py_INCREF(ret);
   25340             :                         } else {
   25341           4 :                                 ret = pytalloc_reference_ex(&DNS_RPC_SERVER_INFO_W2K_Type, in->ServerInfoW2K, in->ServerInfoW2K);
   25342             :                         }
   25343           4 :                         return ret;
   25344             : 
   25345           0 :                 case DNSSRV_TYPEID_STATS:
   25346           0 :                         if (in->Stats == NULL) {
   25347           0 :                                 ret = Py_None;
   25348           0 :                                 Py_INCREF(ret);
   25349             :                         } else {
   25350           0 :                                 ret = pytalloc_reference_ex(&DNSSRV_STAT_Type, in->Stats, in->Stats);
   25351             :                         }
   25352           0 :                         return ret;
   25353             : 
   25354           0 :                 case DNSSRV_TYPEID_FORWARDERS_W2K:
   25355           0 :                         if (in->ForwardersW2K == NULL) {
   25356           0 :                                 ret = Py_None;
   25357           0 :                                 Py_INCREF(ret);
   25358             :                         } else {
   25359           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_FORWARDERS_W2K_Type, in->ForwardersW2K, in->ForwardersW2K);
   25360             :                         }
   25361           0 :                         return ret;
   25362             : 
   25363           0 :                 case DNSSRV_TYPEID_ZONE_W2K:
   25364           0 :                         if (in->ZoneW2K == NULL) {
   25365           0 :                                 ret = Py_None;
   25366           0 :                                 Py_INCREF(ret);
   25367             :                         } else {
   25368           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_ZONE_W2K_Type, in->ZoneW2K, in->ZoneW2K);
   25369             :                         }
   25370           0 :                         return ret;
   25371             : 
   25372           0 :                 case DNSSRV_TYPEID_ZONE_INFO_W2K:
   25373           0 :                         if (in->ZoneInfoW2K == NULL) {
   25374           0 :                                 ret = Py_None;
   25375           0 :                                 Py_INCREF(ret);
   25376             :                         } else {
   25377           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_ZONE_INFO_W2K_Type, in->ZoneInfoW2K, in->ZoneInfoW2K);
   25378             :                         }
   25379           0 :                         return ret;
   25380             : 
   25381           0 :                 case DNSSRV_TYPEID_ZONE_SECONDARIES_W2K:
   25382           0 :                         if (in->SecondariesW2K == NULL) {
   25383           0 :                                 ret = Py_None;
   25384           0 :                                 Py_INCREF(ret);
   25385             :                         } else {
   25386           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_ZONE_SECONDARIES_W2K_Type, in->SecondariesW2K, in->SecondariesW2K);
   25387             :                         }
   25388           0 :                         return ret;
   25389             : 
   25390           0 :                 case DNSSRV_TYPEID_ZONE_DATABASE_W2K:
   25391           0 :                         if (in->DatabaseW2K == NULL) {
   25392           0 :                                 ret = Py_None;
   25393           0 :                                 Py_INCREF(ret);
   25394             :                         } else {
   25395           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_ZONE_DATABASE_W2K_Type, in->DatabaseW2K, in->DatabaseW2K);
   25396             :                         }
   25397           0 :                         return ret;
   25398             : 
   25399           0 :                 case DNSSRV_TYPEID_ZONE_CREATE_W2K:
   25400           0 :                         if (in->ZoneCreateW2K == NULL) {
   25401           0 :                                 ret = Py_None;
   25402           0 :                                 Py_INCREF(ret);
   25403             :                         } else {
   25404           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_ZONE_CREATE_INFO_W2K_Type, in->ZoneCreateW2K, in->ZoneCreateW2K);
   25405             :                         }
   25406           0 :                         return ret;
   25407             : 
   25408           0 :                 case DNSSRV_TYPEID_NAME_AND_PARAM:
   25409           0 :                         if (in->NameAndParam == NULL) {
   25410           0 :                                 ret = Py_None;
   25411           0 :                                 Py_INCREF(ret);
   25412             :                         } else {
   25413           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_NAME_AND_PARAM_Type, in->NameAndParam, in->NameAndParam);
   25414             :                         }
   25415           0 :                         return ret;
   25416             : 
   25417           0 :                 case DNSSRV_TYPEID_ZONE_LIST_W2K:
   25418           0 :                         if (in->ZoneListW2K == NULL) {
   25419           0 :                                 ret = Py_None;
   25420           0 :                                 Py_INCREF(ret);
   25421             :                         } else {
   25422           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_ZONE_LIST_W2K_Type, in->ZoneListW2K, in->ZoneListW2K);
   25423             :                         }
   25424           0 :                         return ret;
   25425             : 
   25426           4 :                 case DNSSRV_TYPEID_SERVER_INFO_DOTNET:
   25427           4 :                         if (in->ServerInfoDotNet == NULL) {
   25428           0 :                                 ret = Py_None;
   25429           0 :                                 Py_INCREF(ret);
   25430             :                         } else {
   25431           4 :                                 ret = pytalloc_reference_ex(&DNS_RPC_SERVER_INFO_DOTNET_Type, in->ServerInfoDotNet, in->ServerInfoDotNet);
   25432             :                         }
   25433           4 :                         return ret;
   25434             : 
   25435           0 :                 case DNSSRV_TYPEID_FORWARDERS_DOTNET:
   25436           0 :                         if (in->ForwardersDotNet == NULL) {
   25437           0 :                                 ret = Py_None;
   25438           0 :                                 Py_INCREF(ret);
   25439             :                         } else {
   25440           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_FORWARDERS_DOTNET_Type, in->ForwardersDotNet, in->ForwardersDotNet);
   25441             :                         }
   25442           0 :                         return ret;
   25443             : 
   25444           0 :                 case DNSSRV_TYPEID_ZONE:
   25445           0 :                         if (in->Zone == NULL) {
   25446           0 :                                 ret = Py_None;
   25447           0 :                                 Py_INCREF(ret);
   25448             :                         } else {
   25449           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_ZONE_DOTNET_Type, in->Zone, in->Zone);
   25450             :                         }
   25451           0 :                         return ret;
   25452             : 
   25453           0 :                 case DNSSRV_TYPEID_ZONE_INFO_DOTNET:
   25454           0 :                         if (in->ZoneInfoDotNet == NULL) {
   25455           0 :                                 ret = Py_None;
   25456           0 :                                 Py_INCREF(ret);
   25457             :                         } else {
   25458           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_ZONE_INFO_DOTNET_Type, in->ZoneInfoDotNet, in->ZoneInfoDotNet);
   25459             :                         }
   25460           0 :                         return ret;
   25461             : 
   25462           0 :                 case DNSSRV_TYPEID_ZONE_SECONDARIES_DOTNET:
   25463           0 :                         if (in->SecondariesDotNet == NULL) {
   25464           0 :                                 ret = Py_None;
   25465           0 :                                 Py_INCREF(ret);
   25466             :                         } else {
   25467           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_ZONE_SECONDARIES_DOTNET_Type, in->SecondariesDotNet, in->SecondariesDotNet);
   25468             :                         }
   25469           0 :                         return ret;
   25470             : 
   25471           0 :                 case DNSSRV_TYPEID_ZONE_DATABASE:
   25472           0 :                         if (in->Database == NULL) {
   25473           0 :                                 ret = Py_None;
   25474           0 :                                 Py_INCREF(ret);
   25475             :                         } else {
   25476           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_ZONE_DATABASE_DOTNET_Type, in->Database, in->Database);
   25477             :                         }
   25478           0 :                         return ret;
   25479             : 
   25480           0 :                 case DNSSRV_TYPEID_ZONE_CREATE_DOTNET:
   25481           0 :                         if (in->ZoneCreateDotNet == NULL) {
   25482           0 :                                 ret = Py_None;
   25483           0 :                                 Py_INCREF(ret);
   25484             :                         } else {
   25485           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_ZONE_CREATE_INFO_DOTNET_Type, in->ZoneCreateDotNet, in->ZoneCreateDotNet);
   25486             :                         }
   25487           0 :                         return ret;
   25488             : 
   25489          20 :                 case DNSSRV_TYPEID_ZONE_LIST:
   25490          20 :                         if (in->ZoneList == NULL) {
   25491           0 :                                 ret = Py_None;
   25492           0 :                                 Py_INCREF(ret);
   25493             :                         } else {
   25494          20 :                                 ret = pytalloc_reference_ex(&DNS_RPC_ZONE_LIST_DOTNET_Type, in->ZoneList, in->ZoneList);
   25495             :                         }
   25496          20 :                         return ret;
   25497             : 
   25498           0 :                 case DNSSRV_TYPEID_ZONE_EXPORT:
   25499           0 :                         if (in->ZoneExport == NULL) {
   25500           0 :                                 ret = Py_None;
   25501           0 :                                 Py_INCREF(ret);
   25502             :                         } else {
   25503           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_ZONE_EXPORT_INFO_Type, in->ZoneExport, in->ZoneExport);
   25504             :                         }
   25505           0 :                         return ret;
   25506             : 
   25507           0 :                 case DNSSRV_TYPEID_DP_INFO:
   25508           0 :                         if (in->DirectoryPartition == NULL) {
   25509           0 :                                 ret = Py_None;
   25510           0 :                                 Py_INCREF(ret);
   25511             :                         } else {
   25512           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_DP_INFO_Type, in->DirectoryPartition, in->DirectoryPartition);
   25513             :                         }
   25514           0 :                         return ret;
   25515             : 
   25516           0 :                 case DNSSRV_TYPEID_DP_ENUM:
   25517           0 :                         if (in->DirectoryPartitionEnum == NULL) {
   25518           0 :                                 ret = Py_None;
   25519           0 :                                 Py_INCREF(ret);
   25520             :                         } else {
   25521           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_DP_ENUM_Type, in->DirectoryPartitionEnum, in->DirectoryPartitionEnum);
   25522             :                         }
   25523           0 :                         return ret;
   25524             : 
   25525           0 :                 case DNSSRV_TYPEID_DP_LIST:
   25526           0 :                         if (in->DirectoryPartitionList == NULL) {
   25527           0 :                                 ret = Py_None;
   25528           0 :                                 Py_INCREF(ret);
   25529             :                         } else {
   25530           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_DP_LIST_Type, in->DirectoryPartitionList, in->DirectoryPartitionList);
   25531             :                         }
   25532           0 :                         return ret;
   25533             : 
   25534           0 :                 case DNSSRV_TYPEID_ENLIST_DP:
   25535           0 :                         if (in->EnlistDirectoryPartition == NULL) {
   25536           0 :                                 ret = Py_None;
   25537           0 :                                 Py_INCREF(ret);
   25538             :                         } else {
   25539           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_ENLIST_DP_Type, in->EnlistDirectoryPartition, in->EnlistDirectoryPartition);
   25540             :                         }
   25541           0 :                         return ret;
   25542             : 
   25543           0 :                 case DNSSRV_TYPEID_ZONE_CHANGE_DP:
   25544           0 :                         if (in->ZoneChangeDirectoryPartition == NULL) {
   25545           0 :                                 ret = Py_None;
   25546           0 :                                 Py_INCREF(ret);
   25547             :                         } else {
   25548           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_ZONE_CHANGE_DP_Type, in->ZoneChangeDirectoryPartition, in->ZoneChangeDirectoryPartition);
   25549             :                         }
   25550           0 :                         return ret;
   25551             : 
   25552           0 :                 case DNSSRV_TYPEID_ENUM_ZONES_FILTER:
   25553           0 :                         if (in->EnumZonesFilter == NULL) {
   25554           0 :                                 ret = Py_None;
   25555           0 :                                 Py_INCREF(ret);
   25556             :                         } else {
   25557           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_ENUM_ZONES_FILTER_Type, in->EnumZonesFilter, in->EnumZonesFilter);
   25558             :                         }
   25559           0 :                         return ret;
   25560             : 
   25561           0 :                 case DNSSRV_TYPEID_ADDRARRAY:
   25562           0 :                         if (in->AddrArray == NULL) {
   25563           0 :                                 ret = Py_None;
   25564           0 :                                 Py_INCREF(ret);
   25565             :                         } else {
   25566           0 :                                 ret = pytalloc_reference_ex(&DNS_ADDR_ARRAY_Type, in->AddrArray, in->AddrArray);
   25567             :                         }
   25568           0 :                         return ret;
   25569             : 
   25570           4 :                 case DNSSRV_TYPEID_SERVER_INFO:
   25571           4 :                         if (in->ServerInfo == NULL) {
   25572           0 :                                 ret = Py_None;
   25573           0 :                                 Py_INCREF(ret);
   25574             :                         } else {
   25575           4 :                                 ret = pytalloc_reference_ex(&DNS_RPC_SERVER_INFO_LONGHORN_Type, in->ServerInfo, in->ServerInfo);
   25576             :                         }
   25577           4 :                         return ret;
   25578             : 
   25579           0 :                 case DNSSRV_TYPEID_ZONE_CREATE:
   25580           0 :                         if (in->ZoneCreate == NULL) {
   25581           0 :                                 ret = Py_None;
   25582           0 :                                 Py_INCREF(ret);
   25583             :                         } else {
   25584           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_ZONE_CREATE_INFO_LONGHORN_Type, in->ZoneCreate, in->ZoneCreate);
   25585             :                         }
   25586           0 :                         return ret;
   25587             : 
   25588           0 :                 case DNSSRV_TYPEID_FORWARDERS:
   25589           0 :                         if (in->Forwarders == NULL) {
   25590           0 :                                 ret = Py_None;
   25591           0 :                                 Py_INCREF(ret);
   25592             :                         } else {
   25593           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_FORWARDERS_LONGHORN_Type, in->Forwarders, in->Forwarders);
   25594             :                         }
   25595           0 :                         return ret;
   25596             : 
   25597           0 :                 case DNSSRV_TYPEID_ZONE_SECONDARIES:
   25598           0 :                         if (in->Secondaries == NULL) {
   25599           0 :                                 ret = Py_None;
   25600           0 :                                 Py_INCREF(ret);
   25601             :                         } else {
   25602           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_ZONE_SECONDARIES_LONGHORN_Type, in->Secondaries, in->Secondaries);
   25603             :                         }
   25604           0 :                         return ret;
   25605             : 
   25606           0 :                 case DNSSRV_TYPEID_IP_VALIDATE:
   25607           0 :                         if (in->IpValidate == NULL) {
   25608           0 :                                 ret = Py_None;
   25609           0 :                                 Py_INCREF(ret);
   25610             :                         } else {
   25611           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_IP_VALIDATE_Type, in->IpValidate, in->IpValidate);
   25612             :                         }
   25613           0 :                         return ret;
   25614             : 
   25615          17 :                 case DNSSRV_TYPEID_ZONE_INFO:
   25616          17 :                         if (in->ZoneInfo == NULL) {
   25617           0 :                                 ret = Py_None;
   25618           0 :                                 Py_INCREF(ret);
   25619             :                         } else {
   25620          17 :                                 ret = pytalloc_reference_ex(&DNS_RPC_ZONE_INFO_LONGHORN_Type, in->ZoneInfo, in->ZoneInfo);
   25621             :                         }
   25622          17 :                         return ret;
   25623             : 
   25624           0 :                 case DNSSRV_TYPEID_AUTOCONFIGURE:
   25625           0 :                         if (in->AutoConfigure == NULL) {
   25626           0 :                                 ret = Py_None;
   25627           0 :                                 Py_INCREF(ret);
   25628             :                         } else {
   25629           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_AUTOCONFIGURE_Type, in->AutoConfigure, in->AutoConfigure);
   25630             :                         }
   25631           0 :                         return ret;
   25632             : 
   25633           0 :                 case DNSSRV_TYPEID_UTF8_STRING_LIST:
   25634           0 :                         if (in->Utf8StringList == NULL) {
   25635           0 :                                 ret = Py_None;
   25636           0 :                                 Py_INCREF(ret);
   25637             :                         } else {
   25638           0 :                                 ret = pytalloc_reference_ex(&DNS_RPC_UTF8_STRING_LIST_Type, in->Utf8StringList, in->Utf8StringList);
   25639             :                         }
   25640           0 :                         return ret;
   25641             : 
   25642             :         }
   25643           0 :         PyErr_SetString(PyExc_TypeError, "unknown union level");
   25644           0 :         return NULL;
   25645             : }
   25646             : 
   25647        1675 : static union DNSSRV_RPC_UNION *py_export_DNSSRV_RPC_UNION(TALLOC_CTX *mem_ctx, int level, PyObject *in)
   25648             : {
   25649        1675 :         union DNSSRV_RPC_UNION *ret = talloc_zero(mem_ctx, union DNSSRV_RPC_UNION);
   25650        1675 :         switch (level) {
   25651         429 :                 case DNSSRV_TYPEID_NULL:
   25652         429 :                         if (in == NULL) {
   25653           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->Null");
   25654           0 :                                 talloc_free(ret); return NULL;
   25655             :                         }
   25656         429 :                         if (in == Py_None) {
   25657         429 :                                 ret->Null = NULL;
   25658             :                         } else {
   25659           0 :                                 ret->Null = talloc_ptrtype(mem_ctx, ret->Null);
   25660           0 :                                 if (ret->Null == NULL) {
   25661           0 :                                         PyErr_NoMemory();
   25662           0 :                                         talloc_free(ret); return NULL;
   25663             :                                 }
   25664             :                                 {
   25665           0 :                                         const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*ret->Null));
   25666           0 :                                         if (PyLong_Check(in)) {
   25667           0 :                                                 unsigned long long test_var;
   25668           0 :                                                 test_var = PyLong_AsUnsignedLongLong(in);
   25669           0 :                                                 if (PyErr_Occurred() != NULL) {
   25670           0 :                                                         talloc_free(ret); return NULL;
   25671             :                                                 }
   25672           0 :                                                 if (test_var > uint_max) {
   25673           0 :                                                         PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   25674             :                                                           PyLong_Type.tp_name, uint_max, test_var);
   25675           0 :                                                         talloc_free(ret); return NULL;
   25676             :                                                 }
   25677           0 :                                                 *ret->Null = test_var;
   25678             :                                         } else {
   25679           0 :                                                 PyErr_Format(PyExc_TypeError, "Expected type %s",
   25680             :                                                   PyLong_Type.tp_name);
   25681           0 :                                                 talloc_free(ret); return NULL;
   25682             :                                         }
   25683             :                                 }
   25684             :                         }
   25685         429 :                         break;
   25686             : 
   25687          20 :                 case DNSSRV_TYPEID_DWORD:
   25688          20 :                         if (in == NULL) {
   25689           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->Dword");
   25690           0 :                                 talloc_free(ret); return NULL;
   25691             :                         }
   25692             :                         {
   25693          20 :                                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(ret->Dword));
   25694          20 :                                 if (PyLong_Check(in)) {
   25695           0 :                                         unsigned long long test_var;
   25696          20 :                                         test_var = PyLong_AsUnsignedLongLong(in);
   25697          20 :                                         if (PyErr_Occurred() != NULL) {
   25698           0 :                                                 talloc_free(ret); return NULL;
   25699             :                                         }
   25700          20 :                                         if (test_var > uint_max) {
   25701           0 :                                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   25702             :                                                   PyLong_Type.tp_name, uint_max, test_var);
   25703           0 :                                                 talloc_free(ret); return NULL;
   25704             :                                         }
   25705          20 :                                         ret->Dword = test_var;
   25706             :                                 } else {
   25707           0 :                                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   25708             :                                           PyLong_Type.tp_name);
   25709           0 :                                         talloc_free(ret); return NULL;
   25710             :                                 }
   25711             :                         }
   25712          20 :                         break;
   25713             : 
   25714           0 :                 case DNSSRV_TYPEID_LPSTR:
   25715           0 :                         if (in == NULL) {
   25716           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->String");
   25717           0 :                                 talloc_free(ret); return NULL;
   25718             :                         }
   25719           0 :                         if (in == Py_None) {
   25720           0 :                                 ret->String = NULL;
   25721             :                         } else {
   25722           0 :                                 ret->String = NULL;
   25723             :                                 {
   25724           0 :                                         const char *test_str;
   25725           0 :                                         const char *talloc_str;
   25726           0 :                                         PyObject *unicode = NULL;
   25727           0 :                                         if (PyUnicode_Check(in)) {
   25728           0 :                                                 unicode = PyUnicode_AsEncodedString(in, "utf-8", "ignore");
   25729           0 :                                                 if (unicode == NULL) {
   25730           0 :                                                         talloc_free(ret); return NULL;
   25731             :                                                 }
   25732           0 :                                                 test_str = PyBytes_AS_STRING(unicode);
   25733           0 :                                         } else if (PyBytes_Check(in)) {
   25734           0 :                                                 test_str = PyBytes_AS_STRING(in);
   25735             :                                         } else {
   25736           0 :                                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(in)->tp_name);
   25737           0 :                                                 talloc_free(ret); return NULL;
   25738             :                                         }
   25739           0 :                                         talloc_str = talloc_strdup(mem_ctx, test_str);
   25740           0 :                                         if (unicode != NULL) {
   25741           0 :                                                 Py_DECREF(unicode);
   25742             :                                         }
   25743           0 :                                         if (talloc_str == NULL) {
   25744           0 :                                                 PyErr_NoMemory();
   25745           0 :                                                 talloc_free(ret); return NULL;
   25746             :                                         }
   25747           0 :                                         ret->String = talloc_str;
   25748             :                                 }
   25749             :                         }
   25750           0 :                         break;
   25751             : 
   25752           0 :                 case DNSSRV_TYPEID_LPWSTR:
   25753           0 :                         if (in == NULL) {
   25754           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->WideString");
   25755           0 :                                 talloc_free(ret); return NULL;
   25756             :                         }
   25757           0 :                         if (in == Py_None) {
   25758           0 :                                 ret->WideString = NULL;
   25759             :                         } else {
   25760           0 :                                 ret->WideString = NULL;
   25761             :                                 {
   25762           0 :                                         const char *test_str;
   25763           0 :                                         const char *talloc_str;
   25764           0 :                                         PyObject *unicode = NULL;
   25765           0 :                                         if (PyUnicode_Check(in)) {
   25766           0 :                                                 unicode = PyUnicode_AsEncodedString(in, "utf-8", "ignore");
   25767           0 :                                                 if (unicode == NULL) {
   25768           0 :                                                         talloc_free(ret); return NULL;
   25769             :                                                 }
   25770           0 :                                                 test_str = PyBytes_AS_STRING(unicode);
   25771           0 :                                         } else if (PyBytes_Check(in)) {
   25772           0 :                                                 test_str = PyBytes_AS_STRING(in);
   25773             :                                         } else {
   25774           0 :                                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(in)->tp_name);
   25775           0 :                                                 talloc_free(ret); return NULL;
   25776             :                                         }
   25777           0 :                                         talloc_str = talloc_strdup(mem_ctx, test_str);
   25778           0 :                                         if (unicode != NULL) {
   25779           0 :                                                 Py_DECREF(unicode);
   25780             :                                         }
   25781           0 :                                         if (talloc_str == NULL) {
   25782           0 :                                                 PyErr_NoMemory();
   25783           0 :                                                 talloc_free(ret); return NULL;
   25784             :                                         }
   25785           0 :                                         ret->WideString = talloc_str;
   25786             :                                 }
   25787             :                         }
   25788           0 :                         break;
   25789             : 
   25790           0 :                 case DNSSRV_TYPEID_IPARRAY:
   25791           0 :                         if (in == NULL) {
   25792           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->IpArray");
   25793           0 :                                 talloc_free(ret); return NULL;
   25794             :                         }
   25795           0 :                         if (in == Py_None) {
   25796           0 :                                 ret->IpArray = NULL;
   25797             :                         } else {
   25798           0 :                                 ret->IpArray = NULL;
   25799           0 :                                 PY_CHECK_TYPE(&IP4_ARRAY_Type, in, talloc_free(ret); return NULL;);
   25800           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   25801           0 :                                         PyErr_NoMemory();
   25802           0 :                                         talloc_free(ret); return NULL;
   25803             :                                 }
   25804           0 :                                 ret->IpArray = (struct IP4_ARRAY *)pytalloc_get_ptr(in);
   25805             :                         }
   25806           0 :                         break;
   25807             : 
   25808           0 :                 case DNSSRV_TYPEID_BUFFER:
   25809           0 :                         if (in == NULL) {
   25810           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->Buffer");
   25811           0 :                                 talloc_free(ret); return NULL;
   25812             :                         }
   25813           0 :                         if (in == Py_None) {
   25814           0 :                                 ret->Buffer = NULL;
   25815             :                         } else {
   25816           0 :                                 ret->Buffer = NULL;
   25817           0 :                                 PY_CHECK_TYPE(&DNS_RPC_BUFFER_Type, in, talloc_free(ret); return NULL;);
   25818           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   25819           0 :                                         PyErr_NoMemory();
   25820           0 :                                         talloc_free(ret); return NULL;
   25821             :                                 }
   25822           0 :                                 ret->Buffer = (struct DNS_RPC_BUFFER *)pytalloc_get_ptr(in);
   25823             :                         }
   25824           0 :                         break;
   25825             : 
   25826           0 :                 case DNSSRV_TYPEID_SERVER_INFO_W2K:
   25827           0 :                         if (in == NULL) {
   25828           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->ServerInfoW2K");
   25829           0 :                                 talloc_free(ret); return NULL;
   25830             :                         }
   25831           0 :                         if (in == Py_None) {
   25832           0 :                                 ret->ServerInfoW2K = NULL;
   25833             :                         } else {
   25834           0 :                                 ret->ServerInfoW2K = NULL;
   25835           0 :                                 PY_CHECK_TYPE(&DNS_RPC_SERVER_INFO_W2K_Type, in, talloc_free(ret); return NULL;);
   25836           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   25837           0 :                                         PyErr_NoMemory();
   25838           0 :                                         talloc_free(ret); return NULL;
   25839             :                                 }
   25840           0 :                                 ret->ServerInfoW2K = (struct DNS_RPC_SERVER_INFO_W2K *)pytalloc_get_ptr(in);
   25841             :                         }
   25842           0 :                         break;
   25843             : 
   25844           0 :                 case DNSSRV_TYPEID_STATS:
   25845           0 :                         if (in == NULL) {
   25846           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->Stats");
   25847           0 :                                 talloc_free(ret); return NULL;
   25848             :                         }
   25849           0 :                         if (in == Py_None) {
   25850           0 :                                 ret->Stats = NULL;
   25851             :                         } else {
   25852           0 :                                 ret->Stats = NULL;
   25853           0 :                                 PY_CHECK_TYPE(&DNSSRV_STAT_Type, in, talloc_free(ret); return NULL;);
   25854           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   25855           0 :                                         PyErr_NoMemory();
   25856           0 :                                         talloc_free(ret); return NULL;
   25857             :                                 }
   25858           0 :                                 ret->Stats = (struct DNSSRV_STAT *)pytalloc_get_ptr(in);
   25859             :                         }
   25860           0 :                         break;
   25861             : 
   25862           0 :                 case DNSSRV_TYPEID_FORWARDERS_W2K:
   25863           0 :                         if (in == NULL) {
   25864           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->ForwardersW2K");
   25865           0 :                                 talloc_free(ret); return NULL;
   25866             :                         }
   25867           0 :                         if (in == Py_None) {
   25868           0 :                                 ret->ForwardersW2K = NULL;
   25869             :                         } else {
   25870           0 :                                 ret->ForwardersW2K = NULL;
   25871           0 :                                 PY_CHECK_TYPE(&DNS_RPC_FORWARDERS_W2K_Type, in, talloc_free(ret); return NULL;);
   25872           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   25873           0 :                                         PyErr_NoMemory();
   25874           0 :                                         talloc_free(ret); return NULL;
   25875             :                                 }
   25876           0 :                                 ret->ForwardersW2K = (struct DNS_RPC_FORWARDERS_W2K *)pytalloc_get_ptr(in);
   25877             :                         }
   25878           0 :                         break;
   25879             : 
   25880           0 :                 case DNSSRV_TYPEID_ZONE_W2K:
   25881           0 :                         if (in == NULL) {
   25882           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->ZoneW2K");
   25883           0 :                                 talloc_free(ret); return NULL;
   25884             :                         }
   25885           0 :                         if (in == Py_None) {
   25886           0 :                                 ret->ZoneW2K = NULL;
   25887             :                         } else {
   25888           0 :                                 ret->ZoneW2K = NULL;
   25889           0 :                                 PY_CHECK_TYPE(&DNS_RPC_ZONE_W2K_Type, in, talloc_free(ret); return NULL;);
   25890           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   25891           0 :                                         PyErr_NoMemory();
   25892           0 :                                         talloc_free(ret); return NULL;
   25893             :                                 }
   25894           0 :                                 ret->ZoneW2K = (struct DNS_RPC_ZONE_W2K *)pytalloc_get_ptr(in);
   25895             :                         }
   25896           0 :                         break;
   25897             : 
   25898           0 :                 case DNSSRV_TYPEID_ZONE_INFO_W2K:
   25899           0 :                         if (in == NULL) {
   25900           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->ZoneInfoW2K");
   25901           0 :                                 talloc_free(ret); return NULL;
   25902             :                         }
   25903           0 :                         if (in == Py_None) {
   25904           0 :                                 ret->ZoneInfoW2K = NULL;
   25905             :                         } else {
   25906           0 :                                 ret->ZoneInfoW2K = NULL;
   25907           0 :                                 PY_CHECK_TYPE(&DNS_RPC_ZONE_INFO_W2K_Type, in, talloc_free(ret); return NULL;);
   25908           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   25909           0 :                                         PyErr_NoMemory();
   25910           0 :                                         talloc_free(ret); return NULL;
   25911             :                                 }
   25912           0 :                                 ret->ZoneInfoW2K = (struct DNS_RPC_ZONE_INFO_W2K *)pytalloc_get_ptr(in);
   25913             :                         }
   25914           0 :                         break;
   25915             : 
   25916           0 :                 case DNSSRV_TYPEID_ZONE_SECONDARIES_W2K:
   25917           0 :                         if (in == NULL) {
   25918           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->SecondariesW2K");
   25919           0 :                                 talloc_free(ret); return NULL;
   25920             :                         }
   25921           0 :                         if (in == Py_None) {
   25922           0 :                                 ret->SecondariesW2K = NULL;
   25923             :                         } else {
   25924           0 :                                 ret->SecondariesW2K = NULL;
   25925           0 :                                 PY_CHECK_TYPE(&DNS_RPC_ZONE_SECONDARIES_W2K_Type, in, talloc_free(ret); return NULL;);
   25926           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   25927           0 :                                         PyErr_NoMemory();
   25928           0 :                                         talloc_free(ret); return NULL;
   25929             :                                 }
   25930           0 :                                 ret->SecondariesW2K = (struct DNS_RPC_ZONE_SECONDARIES_W2K *)pytalloc_get_ptr(in);
   25931             :                         }
   25932           0 :                         break;
   25933             : 
   25934           0 :                 case DNSSRV_TYPEID_ZONE_DATABASE_W2K:
   25935           0 :                         if (in == NULL) {
   25936           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->DatabaseW2K");
   25937           0 :                                 talloc_free(ret); return NULL;
   25938             :                         }
   25939           0 :                         if (in == Py_None) {
   25940           0 :                                 ret->DatabaseW2K = NULL;
   25941             :                         } else {
   25942           0 :                                 ret->DatabaseW2K = NULL;
   25943           0 :                                 PY_CHECK_TYPE(&DNS_RPC_ZONE_DATABASE_W2K_Type, in, talloc_free(ret); return NULL;);
   25944           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   25945           0 :                                         PyErr_NoMemory();
   25946           0 :                                         talloc_free(ret); return NULL;
   25947             :                                 }
   25948           0 :                                 ret->DatabaseW2K = (struct DNS_RPC_ZONE_DATABASE_W2K *)pytalloc_get_ptr(in);
   25949             :                         }
   25950           0 :                         break;
   25951             : 
   25952           0 :                 case DNSSRV_TYPEID_ZONE_CREATE_W2K:
   25953           0 :                         if (in == NULL) {
   25954           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->ZoneCreateW2K");
   25955           0 :                                 talloc_free(ret); return NULL;
   25956             :                         }
   25957           0 :                         if (in == Py_None) {
   25958           0 :                                 ret->ZoneCreateW2K = NULL;
   25959             :                         } else {
   25960           0 :                                 ret->ZoneCreateW2K = NULL;
   25961           0 :                                 PY_CHECK_TYPE(&DNS_RPC_ZONE_CREATE_INFO_W2K_Type, in, talloc_free(ret); return NULL;);
   25962           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   25963           0 :                                         PyErr_NoMemory();
   25964           0 :                                         talloc_free(ret); return NULL;
   25965             :                                 }
   25966           0 :                                 ret->ZoneCreateW2K = (struct DNS_RPC_ZONE_CREATE_INFO_W2K *)pytalloc_get_ptr(in);
   25967             :                         }
   25968           0 :                         break;
   25969             : 
   25970         799 :                 case DNSSRV_TYPEID_NAME_AND_PARAM:
   25971         799 :                         if (in == NULL) {
   25972           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->NameAndParam");
   25973           0 :                                 talloc_free(ret); return NULL;
   25974             :                         }
   25975         799 :                         if (in == Py_None) {
   25976           0 :                                 ret->NameAndParam = NULL;
   25977             :                         } else {
   25978         799 :                                 ret->NameAndParam = NULL;
   25979         799 :                                 PY_CHECK_TYPE(&DNS_RPC_NAME_AND_PARAM_Type, in, talloc_free(ret); return NULL;);
   25980         799 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   25981           0 :                                         PyErr_NoMemory();
   25982           0 :                                         talloc_free(ret); return NULL;
   25983             :                                 }
   25984         799 :                                 ret->NameAndParam = (struct DNS_RPC_NAME_AND_PARAM *)pytalloc_get_ptr(in);
   25985             :                         }
   25986         799 :                         break;
   25987             : 
   25988           0 :                 case DNSSRV_TYPEID_ZONE_LIST_W2K:
   25989           0 :                         if (in == NULL) {
   25990           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->ZoneListW2K");
   25991           0 :                                 talloc_free(ret); return NULL;
   25992             :                         }
   25993           0 :                         if (in == Py_None) {
   25994           0 :                                 ret->ZoneListW2K = NULL;
   25995             :                         } else {
   25996           0 :                                 ret->ZoneListW2K = NULL;
   25997           0 :                                 PY_CHECK_TYPE(&DNS_RPC_ZONE_LIST_W2K_Type, in, talloc_free(ret); return NULL;);
   25998           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   25999           0 :                                         PyErr_NoMemory();
   26000           0 :                                         talloc_free(ret); return NULL;
   26001             :                                 }
   26002           0 :                                 ret->ZoneListW2K = (struct DNS_RPC_ZONE_LIST_W2K *)pytalloc_get_ptr(in);
   26003             :                         }
   26004           0 :                         break;
   26005             : 
   26006           0 :                 case DNSSRV_TYPEID_SERVER_INFO_DOTNET:
   26007           0 :                         if (in == NULL) {
   26008           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->ServerInfoDotNet");
   26009           0 :                                 talloc_free(ret); return NULL;
   26010             :                         }
   26011           0 :                         if (in == Py_None) {
   26012           0 :                                 ret->ServerInfoDotNet = NULL;
   26013             :                         } else {
   26014           0 :                                 ret->ServerInfoDotNet = NULL;
   26015           0 :                                 PY_CHECK_TYPE(&DNS_RPC_SERVER_INFO_DOTNET_Type, in, talloc_free(ret); return NULL;);
   26016           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   26017           0 :                                         PyErr_NoMemory();
   26018           0 :                                         talloc_free(ret); return NULL;
   26019             :                                 }
   26020           0 :                                 ret->ServerInfoDotNet = (struct DNS_RPC_SERVER_INFO_DOTNET *)pytalloc_get_ptr(in);
   26021             :                         }
   26022           0 :                         break;
   26023             : 
   26024           0 :                 case DNSSRV_TYPEID_FORWARDERS_DOTNET:
   26025           0 :                         if (in == NULL) {
   26026           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->ForwardersDotNet");
   26027           0 :                                 talloc_free(ret); return NULL;
   26028             :                         }
   26029           0 :                         if (in == Py_None) {
   26030           0 :                                 ret->ForwardersDotNet = NULL;
   26031             :                         } else {
   26032           0 :                                 ret->ForwardersDotNet = NULL;
   26033           0 :                                 PY_CHECK_TYPE(&DNS_RPC_FORWARDERS_DOTNET_Type, in, talloc_free(ret); return NULL;);
   26034           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   26035           0 :                                         PyErr_NoMemory();
   26036           0 :                                         talloc_free(ret); return NULL;
   26037             :                                 }
   26038           0 :                                 ret->ForwardersDotNet = (struct DNS_RPC_FORWARDERS_DOTNET *)pytalloc_get_ptr(in);
   26039             :                         }
   26040           0 :                         break;
   26041             : 
   26042           0 :                 case DNSSRV_TYPEID_ZONE:
   26043           0 :                         if (in == NULL) {
   26044           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->Zone");
   26045           0 :                                 talloc_free(ret); return NULL;
   26046             :                         }
   26047           0 :                         if (in == Py_None) {
   26048           0 :                                 ret->Zone = NULL;
   26049             :                         } else {
   26050           0 :                                 ret->Zone = NULL;
   26051           0 :                                 PY_CHECK_TYPE(&DNS_RPC_ZONE_DOTNET_Type, in, talloc_free(ret); return NULL;);
   26052           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   26053           0 :                                         PyErr_NoMemory();
   26054           0 :                                         talloc_free(ret); return NULL;
   26055             :                                 }
   26056           0 :                                 ret->Zone = (struct DNS_RPC_ZONE_DOTNET *)pytalloc_get_ptr(in);
   26057             :                         }
   26058           0 :                         break;
   26059             : 
   26060           0 :                 case DNSSRV_TYPEID_ZONE_INFO_DOTNET:
   26061           0 :                         if (in == NULL) {
   26062           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->ZoneInfoDotNet");
   26063           0 :                                 talloc_free(ret); return NULL;
   26064             :                         }
   26065           0 :                         if (in == Py_None) {
   26066           0 :                                 ret->ZoneInfoDotNet = NULL;
   26067             :                         } else {
   26068           0 :                                 ret->ZoneInfoDotNet = NULL;
   26069           0 :                                 PY_CHECK_TYPE(&DNS_RPC_ZONE_INFO_DOTNET_Type, in, talloc_free(ret); return NULL;);
   26070           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   26071           0 :                                         PyErr_NoMemory();
   26072           0 :                                         talloc_free(ret); return NULL;
   26073             :                                 }
   26074           0 :                                 ret->ZoneInfoDotNet = (struct DNS_RPC_ZONE_INFO_DOTNET *)pytalloc_get_ptr(in);
   26075             :                         }
   26076           0 :                         break;
   26077             : 
   26078           0 :                 case DNSSRV_TYPEID_ZONE_SECONDARIES_DOTNET:
   26079           0 :                         if (in == NULL) {
   26080           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->SecondariesDotNet");
   26081           0 :                                 talloc_free(ret); return NULL;
   26082             :                         }
   26083           0 :                         if (in == Py_None) {
   26084           0 :                                 ret->SecondariesDotNet = NULL;
   26085             :                         } else {
   26086           0 :                                 ret->SecondariesDotNet = NULL;
   26087           0 :                                 PY_CHECK_TYPE(&DNS_RPC_ZONE_SECONDARIES_DOTNET_Type, in, talloc_free(ret); return NULL;);
   26088           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   26089           0 :                                         PyErr_NoMemory();
   26090           0 :                                         talloc_free(ret); return NULL;
   26091             :                                 }
   26092           0 :                                 ret->SecondariesDotNet = (struct DNS_RPC_ZONE_SECONDARIES_DOTNET *)pytalloc_get_ptr(in);
   26093             :                         }
   26094           0 :                         break;
   26095             : 
   26096           0 :                 case DNSSRV_TYPEID_ZONE_DATABASE:
   26097           0 :                         if (in == NULL) {
   26098           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->Database");
   26099           0 :                                 talloc_free(ret); return NULL;
   26100             :                         }
   26101           0 :                         if (in == Py_None) {
   26102           0 :                                 ret->Database = NULL;
   26103             :                         } else {
   26104           0 :                                 ret->Database = NULL;
   26105           0 :                                 PY_CHECK_TYPE(&DNS_RPC_ZONE_DATABASE_DOTNET_Type, in, talloc_free(ret); return NULL;);
   26106           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   26107           0 :                                         PyErr_NoMemory();
   26108           0 :                                         talloc_free(ret); return NULL;
   26109             :                                 }
   26110           0 :                                 ret->Database = (struct DNS_RPC_ZONE_DATABASE_DOTNET *)pytalloc_get_ptr(in);
   26111             :                         }
   26112           0 :                         break;
   26113             : 
   26114           0 :                 case DNSSRV_TYPEID_ZONE_CREATE_DOTNET:
   26115           0 :                         if (in == NULL) {
   26116           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->ZoneCreateDotNet");
   26117           0 :                                 talloc_free(ret); return NULL;
   26118             :                         }
   26119           0 :                         if (in == Py_None) {
   26120           0 :                                 ret->ZoneCreateDotNet = NULL;
   26121             :                         } else {
   26122           0 :                                 ret->ZoneCreateDotNet = NULL;
   26123           0 :                                 PY_CHECK_TYPE(&DNS_RPC_ZONE_CREATE_INFO_DOTNET_Type, in, talloc_free(ret); return NULL;);
   26124           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   26125           0 :                                         PyErr_NoMemory();
   26126           0 :                                         talloc_free(ret); return NULL;
   26127             :                                 }
   26128           0 :                                 ret->ZoneCreateDotNet = (struct DNS_RPC_ZONE_CREATE_INFO_DOTNET *)pytalloc_get_ptr(in);
   26129             :                         }
   26130           0 :                         break;
   26131             : 
   26132           0 :                 case DNSSRV_TYPEID_ZONE_LIST:
   26133           0 :                         if (in == NULL) {
   26134           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->ZoneList");
   26135           0 :                                 talloc_free(ret); return NULL;
   26136             :                         }
   26137           0 :                         if (in == Py_None) {
   26138           0 :                                 ret->ZoneList = NULL;
   26139             :                         } else {
   26140           0 :                                 ret->ZoneList = NULL;
   26141           0 :                                 PY_CHECK_TYPE(&DNS_RPC_ZONE_LIST_DOTNET_Type, in, talloc_free(ret); return NULL;);
   26142           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   26143           0 :                                         PyErr_NoMemory();
   26144           0 :                                         talloc_free(ret); return NULL;
   26145             :                                 }
   26146           0 :                                 ret->ZoneList = (struct DNS_RPC_ZONE_LIST_DOTNET *)pytalloc_get_ptr(in);
   26147             :                         }
   26148           0 :                         break;
   26149             : 
   26150           0 :                 case DNSSRV_TYPEID_ZONE_EXPORT:
   26151           0 :                         if (in == NULL) {
   26152           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->ZoneExport");
   26153           0 :                                 talloc_free(ret); return NULL;
   26154             :                         }
   26155           0 :                         if (in == Py_None) {
   26156           0 :                                 ret->ZoneExport = NULL;
   26157             :                         } else {
   26158           0 :                                 ret->ZoneExport = NULL;
   26159           0 :                                 PY_CHECK_TYPE(&DNS_RPC_ZONE_EXPORT_INFO_Type, in, talloc_free(ret); return NULL;);
   26160           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   26161           0 :                                         PyErr_NoMemory();
   26162           0 :                                         talloc_free(ret); return NULL;
   26163             :                                 }
   26164           0 :                                 ret->ZoneExport = (struct DNS_RPC_ZONE_EXPORT_INFO *)pytalloc_get_ptr(in);
   26165             :                         }
   26166           0 :                         break;
   26167             : 
   26168           0 :                 case DNSSRV_TYPEID_DP_INFO:
   26169           0 :                         if (in == NULL) {
   26170           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->DirectoryPartition");
   26171           0 :                                 talloc_free(ret); return NULL;
   26172             :                         }
   26173           0 :                         if (in == Py_None) {
   26174           0 :                                 ret->DirectoryPartition = NULL;
   26175             :                         } else {
   26176           0 :                                 ret->DirectoryPartition = NULL;
   26177           0 :                                 PY_CHECK_TYPE(&DNS_RPC_DP_INFO_Type, in, talloc_free(ret); return NULL;);
   26178           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   26179           0 :                                         PyErr_NoMemory();
   26180           0 :                                         talloc_free(ret); return NULL;
   26181             :                                 }
   26182           0 :                                 ret->DirectoryPartition = (struct DNS_RPC_DP_INFO *)pytalloc_get_ptr(in);
   26183             :                         }
   26184           0 :                         break;
   26185             : 
   26186           0 :                 case DNSSRV_TYPEID_DP_ENUM:
   26187           0 :                         if (in == NULL) {
   26188           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->DirectoryPartitionEnum");
   26189           0 :                                 talloc_free(ret); return NULL;
   26190             :                         }
   26191           0 :                         if (in == Py_None) {
   26192           0 :                                 ret->DirectoryPartitionEnum = NULL;
   26193             :                         } else {
   26194           0 :                                 ret->DirectoryPartitionEnum = NULL;
   26195           0 :                                 PY_CHECK_TYPE(&DNS_RPC_DP_ENUM_Type, in, talloc_free(ret); return NULL;);
   26196           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   26197           0 :                                         PyErr_NoMemory();
   26198           0 :                                         talloc_free(ret); return NULL;
   26199             :                                 }
   26200           0 :                                 ret->DirectoryPartitionEnum = (struct DNS_RPC_DP_ENUM *)pytalloc_get_ptr(in);
   26201             :                         }
   26202           0 :                         break;
   26203             : 
   26204           0 :                 case DNSSRV_TYPEID_DP_LIST:
   26205           0 :                         if (in == NULL) {
   26206           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->DirectoryPartitionList");
   26207           0 :                                 talloc_free(ret); return NULL;
   26208             :                         }
   26209           0 :                         if (in == Py_None) {
   26210           0 :                                 ret->DirectoryPartitionList = NULL;
   26211             :                         } else {
   26212           0 :                                 ret->DirectoryPartitionList = NULL;
   26213           0 :                                 PY_CHECK_TYPE(&DNS_RPC_DP_LIST_Type, in, talloc_free(ret); return NULL;);
   26214           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   26215           0 :                                         PyErr_NoMemory();
   26216           0 :                                         talloc_free(ret); return NULL;
   26217             :                                 }
   26218           0 :                                 ret->DirectoryPartitionList = (struct DNS_RPC_DP_LIST *)pytalloc_get_ptr(in);
   26219             :                         }
   26220           0 :                         break;
   26221             : 
   26222           0 :                 case DNSSRV_TYPEID_ENLIST_DP:
   26223           0 :                         if (in == NULL) {
   26224           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->EnlistDirectoryPartition");
   26225           0 :                                 talloc_free(ret); return NULL;
   26226             :                         }
   26227           0 :                         if (in == Py_None) {
   26228           0 :                                 ret->EnlistDirectoryPartition = NULL;
   26229             :                         } else {
   26230           0 :                                 ret->EnlistDirectoryPartition = NULL;
   26231           0 :                                 PY_CHECK_TYPE(&DNS_RPC_ENLIST_DP_Type, in, talloc_free(ret); return NULL;);
   26232           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   26233           0 :                                         PyErr_NoMemory();
   26234           0 :                                         talloc_free(ret); return NULL;
   26235             :                                 }
   26236           0 :                                 ret->EnlistDirectoryPartition = (struct DNS_RPC_ENLIST_DP *)pytalloc_get_ptr(in);
   26237             :                         }
   26238           0 :                         break;
   26239             : 
   26240           0 :                 case DNSSRV_TYPEID_ZONE_CHANGE_DP:
   26241           0 :                         if (in == NULL) {
   26242           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->ZoneChangeDirectoryPartition");
   26243           0 :                                 talloc_free(ret); return NULL;
   26244             :                         }
   26245           0 :                         if (in == Py_None) {
   26246           0 :                                 ret->ZoneChangeDirectoryPartition = NULL;
   26247             :                         } else {
   26248           0 :                                 ret->ZoneChangeDirectoryPartition = NULL;
   26249           0 :                                 PY_CHECK_TYPE(&DNS_RPC_ZONE_CHANGE_DP_Type, in, talloc_free(ret); return NULL;);
   26250           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   26251           0 :                                         PyErr_NoMemory();
   26252           0 :                                         talloc_free(ret); return NULL;
   26253             :                                 }
   26254           0 :                                 ret->ZoneChangeDirectoryPartition = (struct DNS_RPC_ZONE_CHANGE_DP *)pytalloc_get_ptr(in);
   26255             :                         }
   26256           0 :                         break;
   26257             : 
   26258           0 :                 case DNSSRV_TYPEID_ENUM_ZONES_FILTER:
   26259           0 :                         if (in == NULL) {
   26260           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->EnumZonesFilter");
   26261           0 :                                 talloc_free(ret); return NULL;
   26262             :                         }
   26263           0 :                         if (in == Py_None) {
   26264           0 :                                 ret->EnumZonesFilter = NULL;
   26265             :                         } else {
   26266           0 :                                 ret->EnumZonesFilter = NULL;
   26267           0 :                                 PY_CHECK_TYPE(&DNS_RPC_ENUM_ZONES_FILTER_Type, in, talloc_free(ret); return NULL;);
   26268           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   26269           0 :                                         PyErr_NoMemory();
   26270           0 :                                         talloc_free(ret); return NULL;
   26271             :                                 }
   26272           0 :                                 ret->EnumZonesFilter = (struct DNS_RPC_ENUM_ZONES_FILTER *)pytalloc_get_ptr(in);
   26273             :                         }
   26274           0 :                         break;
   26275             : 
   26276           0 :                 case DNSSRV_TYPEID_ADDRARRAY:
   26277           0 :                         if (in == NULL) {
   26278           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->AddrArray");
   26279           0 :                                 talloc_free(ret); return NULL;
   26280             :                         }
   26281           0 :                         if (in == Py_None) {
   26282           0 :                                 ret->AddrArray = NULL;
   26283             :                         } else {
   26284           0 :                                 ret->AddrArray = NULL;
   26285           0 :                                 PY_CHECK_TYPE(&DNS_ADDR_ARRAY_Type, in, talloc_free(ret); return NULL;);
   26286           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   26287           0 :                                         PyErr_NoMemory();
   26288           0 :                                         talloc_free(ret); return NULL;
   26289             :                                 }
   26290           0 :                                 ret->AddrArray = (struct DNS_ADDR_ARRAY *)pytalloc_get_ptr(in);
   26291             :                         }
   26292           0 :                         break;
   26293             : 
   26294           0 :                 case DNSSRV_TYPEID_SERVER_INFO:
   26295           0 :                         if (in == NULL) {
   26296           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->ServerInfo");
   26297           0 :                                 talloc_free(ret); return NULL;
   26298             :                         }
   26299           0 :                         if (in == Py_None) {
   26300           0 :                                 ret->ServerInfo = NULL;
   26301             :                         } else {
   26302           0 :                                 ret->ServerInfo = NULL;
   26303           0 :                                 PY_CHECK_TYPE(&DNS_RPC_SERVER_INFO_LONGHORN_Type, in, talloc_free(ret); return NULL;);
   26304           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   26305           0 :                                         PyErr_NoMemory();
   26306           0 :                                         talloc_free(ret); return NULL;
   26307             :                                 }
   26308           0 :                                 ret->ServerInfo = (struct DNS_RPC_SERVER_INFO_LONGHORN *)pytalloc_get_ptr(in);
   26309             :                         }
   26310           0 :                         break;
   26311             : 
   26312         427 :                 case DNSSRV_TYPEID_ZONE_CREATE:
   26313         427 :                         if (in == NULL) {
   26314           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->ZoneCreate");
   26315           0 :                                 talloc_free(ret); return NULL;
   26316             :                         }
   26317         427 :                         if (in == Py_None) {
   26318           0 :                                 ret->ZoneCreate = NULL;
   26319             :                         } else {
   26320         427 :                                 ret->ZoneCreate = NULL;
   26321         427 :                                 PY_CHECK_TYPE(&DNS_RPC_ZONE_CREATE_INFO_LONGHORN_Type, in, talloc_free(ret); return NULL;);
   26322         427 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   26323           0 :                                         PyErr_NoMemory();
   26324           0 :                                         talloc_free(ret); return NULL;
   26325             :                                 }
   26326         427 :                                 ret->ZoneCreate = (struct DNS_RPC_ZONE_CREATE_INFO_LONGHORN *)pytalloc_get_ptr(in);
   26327             :                         }
   26328         427 :                         break;
   26329             : 
   26330           0 :                 case DNSSRV_TYPEID_FORWARDERS:
   26331           0 :                         if (in == NULL) {
   26332           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->Forwarders");
   26333           0 :                                 talloc_free(ret); return NULL;
   26334             :                         }
   26335           0 :                         if (in == Py_None) {
   26336           0 :                                 ret->Forwarders = NULL;
   26337             :                         } else {
   26338           0 :                                 ret->Forwarders = NULL;
   26339           0 :                                 PY_CHECK_TYPE(&DNS_RPC_FORWARDERS_LONGHORN_Type, in, talloc_free(ret); return NULL;);
   26340           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   26341           0 :                                         PyErr_NoMemory();
   26342           0 :                                         talloc_free(ret); return NULL;
   26343             :                                 }
   26344           0 :                                 ret->Forwarders = (struct DNS_RPC_FORWARDERS_LONGHORN *)pytalloc_get_ptr(in);
   26345             :                         }
   26346           0 :                         break;
   26347             : 
   26348           0 :                 case DNSSRV_TYPEID_ZONE_SECONDARIES:
   26349           0 :                         if (in == NULL) {
   26350           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->Secondaries");
   26351           0 :                                 talloc_free(ret); return NULL;
   26352             :                         }
   26353           0 :                         if (in == Py_None) {
   26354           0 :                                 ret->Secondaries = NULL;
   26355             :                         } else {
   26356           0 :                                 ret->Secondaries = NULL;
   26357           0 :                                 PY_CHECK_TYPE(&DNS_RPC_ZONE_SECONDARIES_LONGHORN_Type, in, talloc_free(ret); return NULL;);
   26358           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   26359           0 :                                         PyErr_NoMemory();
   26360           0 :                                         talloc_free(ret); return NULL;
   26361             :                                 }
   26362           0 :                                 ret->Secondaries = (struct DNS_RPC_ZONE_SECONDARIES_LONGHORN *)pytalloc_get_ptr(in);
   26363             :                         }
   26364           0 :                         break;
   26365             : 
   26366           0 :                 case DNSSRV_TYPEID_IP_VALIDATE:
   26367           0 :                         if (in == NULL) {
   26368           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->IpValidate");
   26369           0 :                                 talloc_free(ret); return NULL;
   26370             :                         }
   26371           0 :                         if (in == Py_None) {
   26372           0 :                                 ret->IpValidate = NULL;
   26373             :                         } else {
   26374           0 :                                 ret->IpValidate = NULL;
   26375           0 :                                 PY_CHECK_TYPE(&DNS_RPC_IP_VALIDATE_Type, in, talloc_free(ret); return NULL;);
   26376           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   26377           0 :                                         PyErr_NoMemory();
   26378           0 :                                         talloc_free(ret); return NULL;
   26379             :                                 }
   26380           0 :                                 ret->IpValidate = (struct DNS_RPC_IP_VALIDATE *)pytalloc_get_ptr(in);
   26381             :                         }
   26382           0 :                         break;
   26383             : 
   26384           0 :                 case DNSSRV_TYPEID_ZONE_INFO:
   26385           0 :                         if (in == NULL) {
   26386           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->ZoneInfo");
   26387           0 :                                 talloc_free(ret); return NULL;
   26388             :                         }
   26389           0 :                         if (in == Py_None) {
   26390           0 :                                 ret->ZoneInfo = NULL;
   26391             :                         } else {
   26392           0 :                                 ret->ZoneInfo = NULL;
   26393           0 :                                 PY_CHECK_TYPE(&DNS_RPC_ZONE_INFO_LONGHORN_Type, in, talloc_free(ret); return NULL;);
   26394           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   26395           0 :                                         PyErr_NoMemory();
   26396           0 :                                         talloc_free(ret); return NULL;
   26397             :                                 }
   26398           0 :                                 ret->ZoneInfo = (struct DNS_RPC_ZONE_INFO_LONGHORN *)pytalloc_get_ptr(in);
   26399             :                         }
   26400           0 :                         break;
   26401             : 
   26402           0 :                 case DNSSRV_TYPEID_AUTOCONFIGURE:
   26403           0 :                         if (in == NULL) {
   26404           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->AutoConfigure");
   26405           0 :                                 talloc_free(ret); return NULL;
   26406             :                         }
   26407           0 :                         if (in == Py_None) {
   26408           0 :                                 ret->AutoConfigure = NULL;
   26409             :                         } else {
   26410           0 :                                 ret->AutoConfigure = NULL;
   26411           0 :                                 PY_CHECK_TYPE(&DNS_RPC_AUTOCONFIGURE_Type, in, talloc_free(ret); return NULL;);
   26412           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   26413           0 :                                         PyErr_NoMemory();
   26414           0 :                                         talloc_free(ret); return NULL;
   26415             :                                 }
   26416           0 :                                 ret->AutoConfigure = (struct DNS_RPC_AUTOCONFIGURE *)pytalloc_get_ptr(in);
   26417             :                         }
   26418           0 :                         break;
   26419             : 
   26420           0 :                 case DNSSRV_TYPEID_UTF8_STRING_LIST:
   26421           0 :                         if (in == NULL) {
   26422           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: ret->Utf8StringList");
   26423           0 :                                 talloc_free(ret); return NULL;
   26424             :                         }
   26425           0 :                         if (in == Py_None) {
   26426           0 :                                 ret->Utf8StringList = NULL;
   26427             :                         } else {
   26428           0 :                                 ret->Utf8StringList = NULL;
   26429           0 :                                 PY_CHECK_TYPE(&DNS_RPC_UTF8_STRING_LIST_Type, in, talloc_free(ret); return NULL;);
   26430           0 :                                 if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
   26431           0 :                                         PyErr_NoMemory();
   26432           0 :                                         talloc_free(ret); return NULL;
   26433             :                                 }
   26434           0 :                                 ret->Utf8StringList = (struct DNS_RPC_UTF8_STRING_LIST *)pytalloc_get_ptr(in);
   26435             :                         }
   26436           0 :                         break;
   26437             : 
   26438           0 :                 default:
   26439           0 :                         PyErr_SetString(PyExc_TypeError, "invalid union level value");
   26440           0 :                         talloc_free(ret);
   26441           0 :                         ret = NULL;
   26442             :         }
   26443             : 
   26444        1675 :         return ret;
   26445             : }
   26446             : 
   26447          49 : static PyObject *py_DNSSRV_RPC_UNION_import(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   26448             : {
   26449          49 :         const char * const kwnames[] = { "mem_ctx", "level", "in", NULL };
   26450          49 :         PyObject *mem_ctx_obj = NULL;
   26451          49 :         TALLOC_CTX *mem_ctx = NULL;
   26452          49 :         int level = 0;
   26453          49 :         PyObject *in_obj = NULL;
   26454          49 :         union DNSSRV_RPC_UNION *in = NULL;
   26455             : 
   26456          49 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OiO:import",
   26457             :                 discard_const_p(char *, kwnames),
   26458             :                 &mem_ctx_obj,
   26459             :                 &level,
   26460             :                 &in_obj)) {
   26461           0 :                 return NULL;
   26462             :         }
   26463          49 :         mem_ctx = pytalloc_get_ptr(mem_ctx_obj);
   26464          49 :         if (mem_ctx == NULL) {
   26465           0 :                 PyErr_SetString(PyExc_TypeError, "mem_ctx is NULL)!");
   26466           0 :                 return NULL;
   26467             :         }
   26468          49 :         in = (union DNSSRV_RPC_UNION *)pytalloc_get_ptr(in_obj);
   26469          49 :         if (in == NULL) {
   26470           0 :                 PyErr_Format(PyExc_TypeError, "in needs to be a pointer to union DNSSRV_RPC_UNION!");
   26471           0 :                 return NULL;
   26472             :         }
   26473             : 
   26474          49 :         return py_import_DNSSRV_RPC_UNION(mem_ctx, level, in);
   26475             : }
   26476             : 
   26477        1675 : static PyObject *py_DNSSRV_RPC_UNION_export(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   26478             : {
   26479        1675 :         const char * const kwnames[] = { "mem_ctx", "level", "in", NULL };
   26480        1675 :         PyObject *mem_ctx_obj = NULL;
   26481        1675 :         TALLOC_CTX *mem_ctx = NULL;
   26482        1675 :         int level = 0;
   26483        1675 :         PyObject *in = NULL;
   26484        1675 :         union DNSSRV_RPC_UNION *out = NULL;
   26485             : 
   26486        1675 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OiO:export",
   26487             :                 discard_const_p(char *, kwnames),
   26488             :                 &mem_ctx_obj,
   26489             :                 &level,
   26490             :                 &in)) {
   26491           0 :                 return NULL;
   26492             :         }
   26493        1675 :         mem_ctx = pytalloc_get_ptr(mem_ctx_obj);
   26494        1675 :         if (mem_ctx == NULL) {
   26495           0 :                 PyErr_SetString(PyExc_TypeError, "mem_ctx is NULL)!");
   26496           0 :                 return NULL;
   26497             :         }
   26498             : 
   26499        1675 :         out = py_export_DNSSRV_RPC_UNION(mem_ctx, level, in);
   26500        1675 :         if (out == NULL) {
   26501           0 :                 return NULL;
   26502             :         }
   26503             : 
   26504        1675 :         return pytalloc_GenericObject_reference(out);
   26505             : }
   26506             : 
   26507             : static PyMethodDef py_DNSSRV_RPC_UNION_methods[] = {
   26508             :         { "__import__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DNSSRV_RPC_UNION_import),
   26509             :                 METH_VARARGS|METH_KEYWORDS|METH_CLASS,
   26510             :                 "T.__import__(mem_ctx, level, in) => ret." },
   26511             :         { "__export__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DNSSRV_RPC_UNION_export),
   26512             :                 METH_VARARGS|METH_KEYWORDS|METH_CLASS,
   26513             :                 "T.__export__(mem_ctx, level, in) => ret." },
   26514             :         { NULL, NULL, 0, NULL }
   26515             : };
   26516             : 
   26517           0 : static PyObject *py_DNSSRV_RPC_UNION_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   26518             : {
   26519           0 :         PyErr_Format(PyExc_TypeError, "New %s Objects are not supported", type->tp_name);
   26520           0 :         return NULL;
   26521             : }
   26522             : 
   26523             : 
   26524             : static PyTypeObject DNSSRV_RPC_UNION_Type = {
   26525             :         PyVarObject_HEAD_INIT(NULL, 0)
   26526             :         .tp_name = "dnsserver.DNSSRV_RPC_UNION",
   26527             :         .tp_getset = NULL,
   26528             :         .tp_methods = py_DNSSRV_RPC_UNION_methods,
   26529             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   26530             :         .tp_new = py_DNSSRV_RPC_UNION_new,
   26531             : };
   26532             : 
   26533             : 
   26534           0 : static PyObject *py_DNS_RPC_RECORDS_get_wLength(PyObject *obj, void *closure)
   26535             : {
   26536           0 :         struct DNS_RPC_RECORDS *object = pytalloc_get_ptr(obj);
   26537           0 :         PyObject *py_wLength;
   26538           0 :         py_wLength = PyLong_FromLong((uint16_t)(object->wLength));
   26539           0 :         return py_wLength;
   26540             : }
   26541             : 
   26542           0 : static int py_DNS_RPC_RECORDS_set_wLength(PyObject *py_obj, PyObject *value, void *closure)
   26543             : {
   26544           0 :         struct DNS_RPC_RECORDS *object = pytalloc_get_ptr(py_obj);
   26545           0 :         if (value == NULL) {
   26546           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->wLength");
   26547           0 :                 return -1;
   26548             :         }
   26549             :         {
   26550           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->wLength));
   26551           0 :                 if (PyLong_Check(value)) {
   26552           0 :                         unsigned long long test_var;
   26553           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   26554           0 :                         if (PyErr_Occurred() != NULL) {
   26555           0 :                                 return -1;
   26556             :                         }
   26557           0 :                         if (test_var > uint_max) {
   26558           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   26559             :                                   PyLong_Type.tp_name, uint_max, test_var);
   26560           0 :                                 return -1;
   26561             :                         }
   26562           0 :                         object->wLength = test_var;
   26563             :                 } else {
   26564           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   26565             :                           PyLong_Type.tp_name);
   26566           0 :                         return -1;
   26567             :                 }
   26568             :         }
   26569           0 :         return 0;
   26570             : }
   26571             : 
   26572         134 : static PyObject *py_DNS_RPC_RECORDS_get_wRecordCount(PyObject *obj, void *closure)
   26573             : {
   26574         134 :         struct DNS_RPC_RECORDS *object = pytalloc_get_ptr(obj);
   26575           0 :         PyObject *py_wRecordCount;
   26576         134 :         py_wRecordCount = PyLong_FromLong((uint16_t)(object->wRecordCount));
   26577         134 :         return py_wRecordCount;
   26578             : }
   26579             : 
   26580           0 : static int py_DNS_RPC_RECORDS_set_wRecordCount(PyObject *py_obj, PyObject *value, void *closure)
   26581             : {
   26582           0 :         struct DNS_RPC_RECORDS *object = pytalloc_get_ptr(py_obj);
   26583           0 :         if (value == NULL) {
   26584           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->wRecordCount");
   26585           0 :                 return -1;
   26586             :         }
   26587             :         {
   26588           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->wRecordCount));
   26589           0 :                 if (PyLong_Check(value)) {
   26590           0 :                         unsigned long long test_var;
   26591           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   26592           0 :                         if (PyErr_Occurred() != NULL) {
   26593           0 :                                 return -1;
   26594             :                         }
   26595           0 :                         if (test_var > uint_max) {
   26596           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   26597             :                                   PyLong_Type.tp_name, uint_max, test_var);
   26598           0 :                                 return -1;
   26599             :                         }
   26600           0 :                         object->wRecordCount = test_var;
   26601             :                 } else {
   26602           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   26603             :                           PyLong_Type.tp_name);
   26604           0 :                         return -1;
   26605             :                 }
   26606             :         }
   26607           0 :         return 0;
   26608             : }
   26609             : 
   26610           0 : static PyObject *py_DNS_RPC_RECORDS_get_dwFlags(PyObject *obj, void *closure)
   26611             : {
   26612           0 :         struct DNS_RPC_RECORDS *object = pytalloc_get_ptr(obj);
   26613           0 :         PyObject *py_dwFlags;
   26614           0 :         py_dwFlags = PyLong_FromUnsignedLongLong((uint32_t)(object->dwFlags));
   26615           0 :         return py_dwFlags;
   26616             : }
   26617             : 
   26618           0 : static int py_DNS_RPC_RECORDS_set_dwFlags(PyObject *py_obj, PyObject *value, void *closure)
   26619             : {
   26620           0 :         struct DNS_RPC_RECORDS *object = pytalloc_get_ptr(py_obj);
   26621           0 :         if (value == NULL) {
   26622           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwFlags");
   26623           0 :                 return -1;
   26624             :         }
   26625             :         {
   26626           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwFlags));
   26627           0 :                 if (PyLong_Check(value)) {
   26628           0 :                         unsigned long long test_var;
   26629           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   26630           0 :                         if (PyErr_Occurred() != NULL) {
   26631           0 :                                 return -1;
   26632             :                         }
   26633           0 :                         if (test_var > uint_max) {
   26634           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   26635             :                                   PyLong_Type.tp_name, uint_max, test_var);
   26636           0 :                                 return -1;
   26637             :                         }
   26638           0 :                         object->dwFlags = test_var;
   26639             :                 } else {
   26640           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   26641             :                           PyLong_Type.tp_name);
   26642           0 :                         return -1;
   26643             :                 }
   26644             :         }
   26645           0 :         return 0;
   26646             : }
   26647             : 
   26648         128 : static PyObject *py_DNS_RPC_RECORDS_get_dwChildCount(PyObject *obj, void *closure)
   26649             : {
   26650         128 :         struct DNS_RPC_RECORDS *object = pytalloc_get_ptr(obj);
   26651           0 :         PyObject *py_dwChildCount;
   26652         128 :         py_dwChildCount = PyLong_FromUnsignedLongLong((uint32_t)(object->dwChildCount));
   26653         128 :         return py_dwChildCount;
   26654             : }
   26655             : 
   26656           0 : static int py_DNS_RPC_RECORDS_set_dwChildCount(PyObject *py_obj, PyObject *value, void *closure)
   26657             : {
   26658           0 :         struct DNS_RPC_RECORDS *object = pytalloc_get_ptr(py_obj);
   26659           0 :         if (value == NULL) {
   26660           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dwChildCount");
   26661           0 :                 return -1;
   26662             :         }
   26663             :         {
   26664           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->dwChildCount));
   26665           0 :                 if (PyLong_Check(value)) {
   26666           0 :                         unsigned long long test_var;
   26667           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   26668           0 :                         if (PyErr_Occurred() != NULL) {
   26669           0 :                                 return -1;
   26670             :                         }
   26671           0 :                         if (test_var > uint_max) {
   26672           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   26673             :                                   PyLong_Type.tp_name, uint_max, test_var);
   26674           0 :                                 return -1;
   26675             :                         }
   26676           0 :                         object->dwChildCount = test_var;
   26677             :                 } else {
   26678           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   26679             :                           PyLong_Type.tp_name);
   26680           0 :                         return -1;
   26681             :                 }
   26682             :         }
   26683           0 :         return 0;
   26684             : }
   26685             : 
   26686         179 : static PyObject *py_DNS_RPC_RECORDS_get_dnsNodeName(PyObject *obj, void *closure)
   26687             : {
   26688         179 :         struct DNS_RPC_RECORDS *object = pytalloc_get_ptr(obj);
   26689           0 :         PyObject *py_dnsNodeName;
   26690         179 :         py_dnsNodeName = pytalloc_reference_ex(&DNS_RPC_NAME_Type, pytalloc_get_mem_ctx(obj), &object->dnsNodeName);
   26691         179 :         return py_dnsNodeName;
   26692             : }
   26693             : 
   26694           0 : static int py_DNS_RPC_RECORDS_set_dnsNodeName(PyObject *py_obj, PyObject *value, void *closure)
   26695             : {
   26696           0 :         struct DNS_RPC_RECORDS *object = pytalloc_get_ptr(py_obj);
   26697           0 :         if (value == NULL) {
   26698           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->dnsNodeName");
   26699           0 :                 return -1;
   26700             :         }
   26701           0 :         PY_CHECK_TYPE(&DNS_RPC_NAME_Type, value, return -1;);
   26702           0 :         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   26703           0 :                 PyErr_NoMemory();
   26704           0 :                 return -1;
   26705             :         }
   26706           0 :         object->dnsNodeName = *(struct DNS_RPC_NAME *)pytalloc_get_ptr(value);
   26707           0 :         return 0;
   26708             : }
   26709             : 
   26710        1071 : static PyObject *py_DNS_RPC_RECORDS_get_records(PyObject *obj, void *closure)
   26711             : {
   26712        1071 :         struct DNS_RPC_RECORDS *object = pytalloc_get_ptr(obj);
   26713           0 :         PyObject *py_records;
   26714        1071 :         py_records = PyList_New(object->wRecordCount);
   26715        1071 :         if (py_records == NULL) {
   26716           0 :                 return NULL;
   26717             :         }
   26718             :         {
   26719             :                 int records_cntr_0;
   26720        2445 :                 for (records_cntr_0 = 0; records_cntr_0 < (object->wRecordCount); records_cntr_0++) {
   26721           0 :                         PyObject *py_records_0;
   26722        1374 :                         py_records_0 = pytalloc_reference_ex(&DNS_RPC_RECORD_Type, object->records, &(object->records)[records_cntr_0]);
   26723        1374 :                         PyList_SetItem(py_records, records_cntr_0, py_records_0);
   26724             :                 }
   26725             :         }
   26726        1071 :         return py_records;
   26727             : }
   26728             : 
   26729           0 : static int py_DNS_RPC_RECORDS_set_records(PyObject *py_obj, PyObject *value, void *closure)
   26730             : {
   26731           0 :         struct DNS_RPC_RECORDS *object = pytalloc_get_ptr(py_obj);
   26732           0 :         if (value == NULL) {
   26733           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->records");
   26734           0 :                 return -1;
   26735             :         }
   26736           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
   26737             :         {
   26738           0 :                 int records_cntr_0;
   26739           0 :                 object->records = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->records, PyList_GET_SIZE(value));
   26740           0 :                 if (!object->records) { return -1; }
   26741           0 :                 talloc_set_name_const(object->records, "ARRAY: object->records");
   26742           0 :                 for (records_cntr_0 = 0; records_cntr_0 < PyList_GET_SIZE(value); records_cntr_0++) {
   26743           0 :                         if (PyList_GET_ITEM(value, records_cntr_0) == NULL) {
   26744           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->records)[records_cntr_0]");
   26745           0 :                                 return -1;
   26746             :                         }
   26747           0 :                         PY_CHECK_TYPE(&DNS_RPC_RECORD_Type, PyList_GET_ITEM(value, records_cntr_0), return -1;);
   26748           0 :                         if (talloc_reference(object->records, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, records_cntr_0))) == NULL) {
   26749           0 :                                 PyErr_NoMemory();
   26750           0 :                                 return -1;
   26751             :                         }
   26752           0 :                         (object->records)[records_cntr_0] = *(struct DNS_RPC_RECORD *)pytalloc_get_ptr(PyList_GET_ITEM(value, records_cntr_0));
   26753             :                 }
   26754             :         }
   26755           0 :         return 0;
   26756             : }
   26757             : 
   26758             : static PyGetSetDef py_DNS_RPC_RECORDS_getsetters[] = {
   26759             :         {
   26760             :                 .name = discard_const_p(char, "wLength"),
   26761             :                 .get = py_DNS_RPC_RECORDS_get_wLength,
   26762             :                 .set = py_DNS_RPC_RECORDS_set_wLength,
   26763             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
   26764             :         },
   26765             :         {
   26766             :                 .name = discard_const_p(char, "wRecordCount"),
   26767             :                 .get = py_DNS_RPC_RECORDS_get_wRecordCount,
   26768             :                 .set = py_DNS_RPC_RECORDS_set_wRecordCount,
   26769             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
   26770             :         },
   26771             :         {
   26772             :                 .name = discard_const_p(char, "dwFlags"),
   26773             :                 .get = py_DNS_RPC_RECORDS_get_dwFlags,
   26774             :                 .set = py_DNS_RPC_RECORDS_set_dwFlags,
   26775             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   26776             :         },
   26777             :         {
   26778             :                 .name = discard_const_p(char, "dwChildCount"),
   26779             :                 .get = py_DNS_RPC_RECORDS_get_dwChildCount,
   26780             :                 .set = py_DNS_RPC_RECORDS_set_dwChildCount,
   26781             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   26782             :         },
   26783             :         {
   26784             :                 .name = discard_const_p(char, "dnsNodeName"),
   26785             :                 .get = py_DNS_RPC_RECORDS_get_dnsNodeName,
   26786             :                 .set = py_DNS_RPC_RECORDS_set_dnsNodeName,
   26787             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_NAME")
   26788             :         },
   26789             :         {
   26790             :                 .name = discard_const_p(char, "records"),
   26791             :                 .get = py_DNS_RPC_RECORDS_get_records,
   26792             :                 .set = py_DNS_RPC_RECORDS_set_records,
   26793             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_RECORD")
   26794             :         },
   26795             :         { .name = NULL }
   26796             : };
   26797             : 
   26798           0 : static PyObject *py_DNS_RPC_RECORDS_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   26799             : {
   26800           0 :         return pytalloc_new(struct DNS_RPC_RECORDS, type);
   26801             : }
   26802             : 
   26803           0 : static PyObject *py_DNS_RPC_RECORDS_ndr_pack(PyObject *py_obj,  PyObject *Py_UNUSED(ignored))
   26804             : {
   26805           0 :         struct DNS_RPC_RECORDS *object = pytalloc_get_ptr(py_obj);
   26806           0 :         PyObject *ret = NULL;
   26807           0 :         DATA_BLOB blob;
   26808           0 :         enum ndr_err_code err;
   26809           0 :         TALLOC_CTX *tmp_ctx = talloc_new(pytalloc_get_mem_ctx(py_obj));
   26810           0 :         if (tmp_ctx == NULL) {
   26811           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
   26812           0 :                 return NULL;
   26813             :         }
   26814           0 :         err = ndr_push_struct_blob(&blob, tmp_ctx, object, (ndr_push_flags_fn_t)ndr_push_DNS_RPC_RECORDS);
   26815           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   26816           0 :                 TALLOC_FREE(tmp_ctx);
   26817           0 :                 PyErr_SetNdrError(err);
   26818           0 :                 return NULL;
   26819             :         }
   26820             : 
   26821           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
   26822           0 :         TALLOC_FREE(tmp_ctx);
   26823           0 :         return ret;
   26824             : }
   26825             : 
   26826           0 : static PyObject *py_DNS_RPC_RECORDS_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   26827             : {
   26828           0 :         struct DNS_RPC_RECORDS *object = pytalloc_get_ptr(py_obj);
   26829           0 :         DATA_BLOB blob = {.data = NULL, .length = 0};
   26830           0 :         Py_ssize_t blob_length = 0;
   26831           0 :         enum ndr_err_code err;
   26832           0 :         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
   26833           0 :         PyObject *allow_remaining_obj = NULL;
   26834           0 :         bool allow_remaining = false;
   26835             : 
   26836           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|O:__ndr_unpack__",
   26837             :                 discard_const_p(char *, kwnames),
   26838             :                 &blob.data, &blob_length,
   26839             :                 &allow_remaining_obj)) {
   26840           0 :                 return NULL;
   26841             :         }
   26842           0 :         blob.length = blob_length;
   26843             : 
   26844           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
   26845           0 :                 allow_remaining = true;
   26846             :         }
   26847             : 
   26848           0 :         if (allow_remaining) {
   26849           0 :                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_DNS_RPC_RECORDS);
   26850             :         } else {
   26851           0 :                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_DNS_RPC_RECORDS);
   26852             :         }
   26853           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   26854           0 :                 PyErr_SetNdrError(err);
   26855           0 :                 return NULL;
   26856             :         }
   26857             : 
   26858           0 :         Py_RETURN_NONE;
   26859             : }
   26860             : 
   26861           0 : static PyObject *py_DNS_RPC_RECORDS_ndr_print(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
   26862             : {
   26863           0 :         struct DNS_RPC_RECORDS *object = pytalloc_get_ptr(py_obj);
   26864           0 :         PyObject *ret;
   26865           0 :         char *retstr;
   26866             : 
   26867           0 :         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_DNS_RPC_RECORDS, "DNS_RPC_RECORDS", object);
   26868           0 :         ret = PyUnicode_FromString(retstr);
   26869           0 :         talloc_free(retstr);
   26870             : 
   26871           0 :         return ret;
   26872             : }
   26873             : 
   26874             : static PyMethodDef py_DNS_RPC_RECORDS_methods[] = {
   26875             :         { "__ndr_pack__", (PyCFunction)py_DNS_RPC_RECORDS_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
   26876             :         { "__ndr_unpack__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DNS_RPC_RECORDS_ndr_unpack), METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
   26877             :         { "__ndr_print__", (PyCFunction)py_DNS_RPC_RECORDS_ndr_print, METH_NOARGS, "S.ndr_print(object) -> None\nNDR print" },
   26878             :         { NULL, NULL, 0, NULL }
   26879             : };
   26880             : 
   26881             : 
   26882             : static PyTypeObject DNS_RPC_RECORDS_Type = {
   26883             :         PyVarObject_HEAD_INIT(NULL, 0)
   26884             :         .tp_name = "dnsserver.DNS_RPC_RECORDS",
   26885             :         .tp_getset = py_DNS_RPC_RECORDS_getsetters,
   26886             :         .tp_methods = py_DNS_RPC_RECORDS_methods,
   26887             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   26888             :         .tp_new = py_DNS_RPC_RECORDS_new,
   26889             : };
   26890             : 
   26891             : 
   26892         130 : static PyObject *py_DNS_RPC_RECORDS_ARRAY_get_count(PyObject *obj, void *closure)
   26893             : {
   26894         130 :         struct DNS_RPC_RECORDS_ARRAY *object = pytalloc_get_ptr(obj);
   26895           0 :         PyObject *py_count;
   26896         130 :         py_count = PyLong_FromUnsignedLongLong((uint32_t)(object->count));
   26897         130 :         return py_count;
   26898             : }
   26899             : 
   26900           0 : static int py_DNS_RPC_RECORDS_ARRAY_set_count(PyObject *py_obj, PyObject *value, void *closure)
   26901             : {
   26902           0 :         struct DNS_RPC_RECORDS_ARRAY *object = pytalloc_get_ptr(py_obj);
   26903           0 :         if (value == NULL) {
   26904           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->count");
   26905           0 :                 return -1;
   26906             :         }
   26907             :         {
   26908           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->count));
   26909           0 :                 if (PyLong_Check(value)) {
   26910           0 :                         unsigned long long test_var;
   26911           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   26912           0 :                         if (PyErr_Occurred() != NULL) {
   26913           0 :                                 return -1;
   26914             :                         }
   26915           0 :                         if (test_var > uint_max) {
   26916           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   26917             :                                   PyLong_Type.tp_name, uint_max, test_var);
   26918           0 :                                 return -1;
   26919             :                         }
   26920           0 :                         object->count = test_var;
   26921             :                 } else {
   26922           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   26923             :                           PyLong_Type.tp_name);
   26924           0 :                         return -1;
   26925             :                 }
   26926             :         }
   26927           0 :         return 0;
   26928             : }
   26929             : 
   26930        1140 : static PyObject *py_DNS_RPC_RECORDS_ARRAY_get_rec(PyObject *obj, void *closure)
   26931             : {
   26932        1140 :         struct DNS_RPC_RECORDS_ARRAY *object = pytalloc_get_ptr(obj);
   26933           0 :         PyObject *py_rec;
   26934        1140 :         py_rec = PyList_New(object->count);
   26935        1140 :         if (py_rec == NULL) {
   26936           0 :                 return NULL;
   26937             :         }
   26938             :         {
   26939             :                 int rec_cntr_0;
   26940        2622 :                 for (rec_cntr_0 = 0; rec_cntr_0 < (object->count); rec_cntr_0++) {
   26941           0 :                         PyObject *py_rec_0;
   26942        1482 :                         py_rec_0 = pytalloc_reference_ex(&DNS_RPC_RECORDS_Type, object->rec, &(object->rec)[rec_cntr_0]);
   26943        1482 :                         PyList_SetItem(py_rec, rec_cntr_0, py_rec_0);
   26944             :                 }
   26945             :         }
   26946        1140 :         return py_rec;
   26947             : }
   26948             : 
   26949           0 : static int py_DNS_RPC_RECORDS_ARRAY_set_rec(PyObject *py_obj, PyObject *value, void *closure)
   26950             : {
   26951           0 :         struct DNS_RPC_RECORDS_ARRAY *object = pytalloc_get_ptr(py_obj);
   26952           0 :         if (value == NULL) {
   26953           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->rec");
   26954           0 :                 return -1;
   26955             :         }
   26956           0 :         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
   26957             :         {
   26958           0 :                 int rec_cntr_0;
   26959           0 :                 object->rec = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->rec, PyList_GET_SIZE(value));
   26960           0 :                 if (!object->rec) { return -1; }
   26961           0 :                 talloc_set_name_const(object->rec, "ARRAY: object->rec");
   26962           0 :                 for (rec_cntr_0 = 0; rec_cntr_0 < PyList_GET_SIZE(value); rec_cntr_0++) {
   26963           0 :                         if (PyList_GET_ITEM(value, rec_cntr_0) == NULL) {
   26964           0 :                                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: (object->rec)[rec_cntr_0]");
   26965           0 :                                 return -1;
   26966             :                         }
   26967           0 :                         PY_CHECK_TYPE(&DNS_RPC_RECORDS_Type, PyList_GET_ITEM(value, rec_cntr_0), return -1;);
   26968           0 :                         if (talloc_reference(object->rec, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, rec_cntr_0))) == NULL) {
   26969           0 :                                 PyErr_NoMemory();
   26970           0 :                                 return -1;
   26971             :                         }
   26972           0 :                         (object->rec)[rec_cntr_0] = *(struct DNS_RPC_RECORDS *)pytalloc_get_ptr(PyList_GET_ITEM(value, rec_cntr_0));
   26973             :                 }
   26974             :         }
   26975           0 :         return 0;
   26976             : }
   26977             : 
   26978             : static PyGetSetDef py_DNS_RPC_RECORDS_ARRAY_getsetters[] = {
   26979             :         {
   26980             :                 .name = discard_const_p(char, "count"),
   26981             :                 .get = py_DNS_RPC_RECORDS_ARRAY_get_count,
   26982             :                 .set = py_DNS_RPC_RECORDS_ARRAY_set_count,
   26983             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   26984             :         },
   26985             :         {
   26986             :                 .name = discard_const_p(char, "rec"),
   26987             :                 .get = py_DNS_RPC_RECORDS_ARRAY_get_rec,
   26988             :                 .set = py_DNS_RPC_RECORDS_ARRAY_set_rec,
   26989             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_RECORDS")
   26990             :         },
   26991             :         { .name = NULL }
   26992             : };
   26993             : 
   26994           0 : static PyObject *py_DNS_RPC_RECORDS_ARRAY_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   26995             : {
   26996           0 :         return pytalloc_new(struct DNS_RPC_RECORDS_ARRAY, type);
   26997             : }
   26998             : 
   26999           0 : static PyObject *py_DNS_RPC_RECORDS_ARRAY_ndr_pack(PyObject *py_obj,  PyObject *Py_UNUSED(ignored))
   27000             : {
   27001           0 :         struct DNS_RPC_RECORDS_ARRAY *object = pytalloc_get_ptr(py_obj);
   27002           0 :         PyObject *ret = NULL;
   27003           0 :         DATA_BLOB blob;
   27004           0 :         enum ndr_err_code err;
   27005           0 :         TALLOC_CTX *tmp_ctx = talloc_new(pytalloc_get_mem_ctx(py_obj));
   27006           0 :         if (tmp_ctx == NULL) {
   27007           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
   27008           0 :                 return NULL;
   27009             :         }
   27010           0 :         err = ndr_push_struct_blob(&blob, tmp_ctx, object, (ndr_push_flags_fn_t)ndr_push_DNS_RPC_RECORDS_ARRAY);
   27011           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   27012           0 :                 TALLOC_FREE(tmp_ctx);
   27013           0 :                 PyErr_SetNdrError(err);
   27014           0 :                 return NULL;
   27015             :         }
   27016             : 
   27017           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
   27018           0 :         TALLOC_FREE(tmp_ctx);
   27019           0 :         return ret;
   27020             : }
   27021             : 
   27022           0 : static PyObject *py_DNS_RPC_RECORDS_ARRAY_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   27023             : {
   27024           0 :         struct DNS_RPC_RECORDS_ARRAY *object = pytalloc_get_ptr(py_obj);
   27025           0 :         DATA_BLOB blob = {.data = NULL, .length = 0};
   27026           0 :         Py_ssize_t blob_length = 0;
   27027           0 :         enum ndr_err_code err;
   27028           0 :         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
   27029           0 :         PyObject *allow_remaining_obj = NULL;
   27030           0 :         bool allow_remaining = false;
   27031             : 
   27032           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|O:__ndr_unpack__",
   27033             :                 discard_const_p(char *, kwnames),
   27034             :                 &blob.data, &blob_length,
   27035             :                 &allow_remaining_obj)) {
   27036           0 :                 return NULL;
   27037             :         }
   27038           0 :         blob.length = blob_length;
   27039             : 
   27040           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
   27041           0 :                 allow_remaining = true;
   27042             :         }
   27043             : 
   27044           0 :         if (allow_remaining) {
   27045           0 :                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_DNS_RPC_RECORDS_ARRAY);
   27046             :         } else {
   27047           0 :                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_DNS_RPC_RECORDS_ARRAY);
   27048             :         }
   27049           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   27050           0 :                 PyErr_SetNdrError(err);
   27051           0 :                 return NULL;
   27052             :         }
   27053             : 
   27054           0 :         Py_RETURN_NONE;
   27055             : }
   27056             : 
   27057           0 : static PyObject *py_DNS_RPC_RECORDS_ARRAY_ndr_print(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
   27058             : {
   27059           0 :         struct DNS_RPC_RECORDS_ARRAY *object = pytalloc_get_ptr(py_obj);
   27060           0 :         PyObject *ret;
   27061           0 :         char *retstr;
   27062             : 
   27063           0 :         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_DNS_RPC_RECORDS_ARRAY, "DNS_RPC_RECORDS_ARRAY", object);
   27064           0 :         ret = PyUnicode_FromString(retstr);
   27065           0 :         talloc_free(retstr);
   27066             : 
   27067           0 :         return ret;
   27068             : }
   27069             : 
   27070             : static PyMethodDef py_DNS_RPC_RECORDS_ARRAY_methods[] = {
   27071             :         { "__ndr_pack__", (PyCFunction)py_DNS_RPC_RECORDS_ARRAY_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
   27072             :         { "__ndr_unpack__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DNS_RPC_RECORDS_ARRAY_ndr_unpack), METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
   27073             :         { "__ndr_print__", (PyCFunction)py_DNS_RPC_RECORDS_ARRAY_ndr_print, METH_NOARGS, "S.ndr_print(object) -> None\nNDR print" },
   27074             :         { NULL, NULL, 0, NULL }
   27075             : };
   27076             : 
   27077             : 
   27078             : static PyTypeObject DNS_RPC_RECORDS_ARRAY_Type = {
   27079             :         PyVarObject_HEAD_INIT(NULL, 0)
   27080             :         .tp_name = "dnsserver.DNS_RPC_RECORDS_ARRAY",
   27081             :         .tp_getset = py_DNS_RPC_RECORDS_ARRAY_getsetters,
   27082             :         .tp_methods = py_DNS_RPC_RECORDS_ARRAY_methods,
   27083             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   27084             :         .tp_new = py_DNS_RPC_RECORDS_ARRAY_new,
   27085             : };
   27086             : 
   27087             : 
   27088             : 
   27089           0 : static PyObject *py_DnssrvOperation_in_get_pwszServerName(PyObject *obj, void *closure)
   27090             : {
   27091           0 :         struct DnssrvOperation *object = pytalloc_get_ptr(obj);
   27092           0 :         PyObject *py_pwszServerName;
   27093           0 :         if (object->in.pwszServerName == NULL) {
   27094           0 :                 Py_RETURN_NONE;
   27095             :         }
   27096           0 :         if (object->in.pwszServerName == NULL) {
   27097           0 :                 py_pwszServerName = Py_None;
   27098           0 :                 Py_INCREF(py_pwszServerName);
   27099             :         } else {
   27100           0 :                 if (object->in.pwszServerName == NULL) {
   27101           0 :                         py_pwszServerName = Py_None;
   27102           0 :                         Py_INCREF(py_pwszServerName);
   27103             :                 } else {
   27104           0 :                         py_pwszServerName = PyUnicode_Decode(object->in.pwszServerName, strlen(object->in.pwszServerName), "utf-8", "ignore");
   27105             :                 }
   27106             :         }
   27107           0 :         return py_pwszServerName;
   27108             : }
   27109             : 
   27110           0 : static int py_DnssrvOperation_in_set_pwszServerName(PyObject *py_obj, PyObject *value, void *closure)
   27111             : {
   27112           0 :         struct DnssrvOperation *object = pytalloc_get_ptr(py_obj);
   27113           0 :         if (value == NULL) {
   27114           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pwszServerName");
   27115           0 :                 return -1;
   27116             :         }
   27117           0 :         if (value == Py_None) {
   27118           0 :                 object->in.pwszServerName = NULL;
   27119             :         } else {
   27120           0 :                 object->in.pwszServerName = NULL;
   27121             :                 {
   27122           0 :                         const char *test_str;
   27123           0 :                         const char *talloc_str;
   27124           0 :                         PyObject *unicode = NULL;
   27125           0 :                         if (PyUnicode_Check(value)) {
   27126           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   27127           0 :                                 if (unicode == NULL) {
   27128           0 :                                         return -1;
   27129             :                                 }
   27130           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   27131           0 :                         } else if (PyBytes_Check(value)) {
   27132           0 :                                 test_str = PyBytes_AS_STRING(value);
   27133             :                         } else {
   27134           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   27135           0 :                                 return -1;
   27136             :                         }
   27137           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   27138           0 :                         if (unicode != NULL) {
   27139           0 :                                 Py_DECREF(unicode);
   27140             :                         }
   27141           0 :                         if (talloc_str == NULL) {
   27142           0 :                                 PyErr_NoMemory();
   27143           0 :                                 return -1;
   27144             :                         }
   27145           0 :                         object->in.pwszServerName = talloc_str;
   27146             :                 }
   27147             :         }
   27148           0 :         return 0;
   27149             : }
   27150             : 
   27151           0 : static PyObject *py_DnssrvOperation_in_get_pszZone(PyObject *obj, void *closure)
   27152             : {
   27153           0 :         struct DnssrvOperation *object = pytalloc_get_ptr(obj);
   27154           0 :         PyObject *py_pszZone;
   27155           0 :         if (object->in.pszZone == NULL) {
   27156           0 :                 Py_RETURN_NONE;
   27157             :         }
   27158           0 :         if (object->in.pszZone == NULL) {
   27159           0 :                 py_pszZone = Py_None;
   27160           0 :                 Py_INCREF(py_pszZone);
   27161             :         } else {
   27162           0 :                 if (object->in.pszZone == NULL) {
   27163           0 :                         py_pszZone = Py_None;
   27164           0 :                         Py_INCREF(py_pszZone);
   27165             :                 } else {
   27166           0 :                         py_pszZone = PyUnicode_Decode(object->in.pszZone, strlen(object->in.pszZone), "utf-8", "ignore");
   27167             :                 }
   27168             :         }
   27169           0 :         return py_pszZone;
   27170             : }
   27171             : 
   27172           0 : static int py_DnssrvOperation_in_set_pszZone(PyObject *py_obj, PyObject *value, void *closure)
   27173             : {
   27174           0 :         struct DnssrvOperation *object = pytalloc_get_ptr(py_obj);
   27175           0 :         if (value == NULL) {
   27176           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszZone");
   27177           0 :                 return -1;
   27178             :         }
   27179           0 :         if (value == Py_None) {
   27180           0 :                 object->in.pszZone = NULL;
   27181             :         } else {
   27182           0 :                 object->in.pszZone = NULL;
   27183             :                 {
   27184           0 :                         const char *test_str;
   27185           0 :                         const char *talloc_str;
   27186           0 :                         PyObject *unicode = NULL;
   27187           0 :                         if (PyUnicode_Check(value)) {
   27188           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   27189           0 :                                 if (unicode == NULL) {
   27190           0 :                                         return -1;
   27191             :                                 }
   27192           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   27193           0 :                         } else if (PyBytes_Check(value)) {
   27194           0 :                                 test_str = PyBytes_AS_STRING(value);
   27195             :                         } else {
   27196           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   27197           0 :                                 return -1;
   27198             :                         }
   27199           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   27200           0 :                         if (unicode != NULL) {
   27201           0 :                                 Py_DECREF(unicode);
   27202             :                         }
   27203           0 :                         if (talloc_str == NULL) {
   27204           0 :                                 PyErr_NoMemory();
   27205           0 :                                 return -1;
   27206             :                         }
   27207           0 :                         object->in.pszZone = talloc_str;
   27208             :                 }
   27209             :         }
   27210           0 :         return 0;
   27211             : }
   27212             : 
   27213           0 : static PyObject *py_DnssrvOperation_in_get_dwContext(PyObject *obj, void *closure)
   27214             : {
   27215           0 :         struct DnssrvOperation *object = pytalloc_get_ptr(obj);
   27216           0 :         PyObject *py_dwContext;
   27217           0 :         py_dwContext = PyLong_FromUnsignedLongLong((uint32_t)(object->in.dwContext));
   27218           0 :         return py_dwContext;
   27219             : }
   27220             : 
   27221           0 : static int py_DnssrvOperation_in_set_dwContext(PyObject *py_obj, PyObject *value, void *closure)
   27222             : {
   27223           0 :         struct DnssrvOperation *object = pytalloc_get_ptr(py_obj);
   27224           0 :         if (value == NULL) {
   27225           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.dwContext");
   27226           0 :                 return -1;
   27227             :         }
   27228             :         {
   27229           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.dwContext));
   27230           0 :                 if (PyLong_Check(value)) {
   27231           0 :                         unsigned long long test_var;
   27232           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   27233           0 :                         if (PyErr_Occurred() != NULL) {
   27234           0 :                                 return -1;
   27235             :                         }
   27236           0 :                         if (test_var > uint_max) {
   27237           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   27238             :                                   PyLong_Type.tp_name, uint_max, test_var);
   27239           0 :                                 return -1;
   27240             :                         }
   27241           0 :                         object->in.dwContext = test_var;
   27242             :                 } else {
   27243           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   27244             :                           PyLong_Type.tp_name);
   27245           0 :                         return -1;
   27246             :                 }
   27247             :         }
   27248           0 :         return 0;
   27249             : }
   27250             : 
   27251           0 : static PyObject *py_DnssrvOperation_in_get_pszOperation(PyObject *obj, void *closure)
   27252             : {
   27253           0 :         struct DnssrvOperation *object = pytalloc_get_ptr(obj);
   27254           0 :         PyObject *py_pszOperation;
   27255           0 :         if (object->in.pszOperation == NULL) {
   27256           0 :                 Py_RETURN_NONE;
   27257             :         }
   27258           0 :         if (object->in.pszOperation == NULL) {
   27259           0 :                 py_pszOperation = Py_None;
   27260           0 :                 Py_INCREF(py_pszOperation);
   27261             :         } else {
   27262           0 :                 if (object->in.pszOperation == NULL) {
   27263           0 :                         py_pszOperation = Py_None;
   27264           0 :                         Py_INCREF(py_pszOperation);
   27265             :                 } else {
   27266           0 :                         py_pszOperation = PyUnicode_Decode(object->in.pszOperation, strlen(object->in.pszOperation), "utf-8", "ignore");
   27267             :                 }
   27268             :         }
   27269           0 :         return py_pszOperation;
   27270             : }
   27271             : 
   27272           0 : static int py_DnssrvOperation_in_set_pszOperation(PyObject *py_obj, PyObject *value, void *closure)
   27273             : {
   27274           0 :         struct DnssrvOperation *object = pytalloc_get_ptr(py_obj);
   27275           0 :         if (value == NULL) {
   27276           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszOperation");
   27277           0 :                 return -1;
   27278             :         }
   27279           0 :         if (value == Py_None) {
   27280           0 :                 object->in.pszOperation = NULL;
   27281             :         } else {
   27282           0 :                 object->in.pszOperation = NULL;
   27283             :                 {
   27284           0 :                         const char *test_str;
   27285           0 :                         const char *talloc_str;
   27286           0 :                         PyObject *unicode = NULL;
   27287           0 :                         if (PyUnicode_Check(value)) {
   27288           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   27289           0 :                                 if (unicode == NULL) {
   27290           0 :                                         return -1;
   27291             :                                 }
   27292           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   27293           0 :                         } else if (PyBytes_Check(value)) {
   27294           0 :                                 test_str = PyBytes_AS_STRING(value);
   27295             :                         } else {
   27296           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   27297           0 :                                 return -1;
   27298             :                         }
   27299           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   27300           0 :                         if (unicode != NULL) {
   27301           0 :                                 Py_DECREF(unicode);
   27302             :                         }
   27303           0 :                         if (talloc_str == NULL) {
   27304           0 :                                 PyErr_NoMemory();
   27305           0 :                                 return -1;
   27306             :                         }
   27307           0 :                         object->in.pszOperation = talloc_str;
   27308             :                 }
   27309             :         }
   27310           0 :         return 0;
   27311             : }
   27312             : 
   27313           0 : static PyObject *py_DnssrvOperation_in_get_dwTypeId(PyObject *obj, void *closure)
   27314             : {
   27315           0 :         struct DnssrvOperation *object = pytalloc_get_ptr(obj);
   27316           0 :         PyObject *py_dwTypeId;
   27317           0 :         py_dwTypeId = PyLong_FromUnsignedLongLong((uint32_t)(object->in.dwTypeId));
   27318           0 :         return py_dwTypeId;
   27319             : }
   27320             : 
   27321           0 : static int py_DnssrvOperation_in_set_dwTypeId(PyObject *py_obj, PyObject *value, void *closure)
   27322             : {
   27323           0 :         struct DnssrvOperation *object = pytalloc_get_ptr(py_obj);
   27324           0 :         if (value == NULL) {
   27325           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.dwTypeId");
   27326           0 :                 return -1;
   27327             :         }
   27328             :         {
   27329           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.dwTypeId));
   27330           0 :                 if (PyLong_Check(value)) {
   27331           0 :                         unsigned long long test_var;
   27332           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   27333           0 :                         if (PyErr_Occurred() != NULL) {
   27334           0 :                                 return -1;
   27335             :                         }
   27336           0 :                         if (test_var > uint_max) {
   27337           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   27338             :                                   PyLong_Type.tp_name, uint_max, test_var);
   27339           0 :                                 return -1;
   27340             :                         }
   27341           0 :                         object->in.dwTypeId = test_var;
   27342             :                 } else {
   27343           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   27344             :                           PyLong_Type.tp_name);
   27345           0 :                         return -1;
   27346             :                 }
   27347             :         }
   27348           0 :         return 0;
   27349             : }
   27350             : 
   27351           0 : static PyObject *py_DnssrvOperation_in_get_pData(PyObject *obj, void *closure)
   27352             : {
   27353           0 :         struct DnssrvOperation *object = pytalloc_get_ptr(obj);
   27354           0 :         PyObject *py_pData;
   27355           0 :         py_pData = pyrpc_import_union(&DNSSRV_RPC_UNION_Type, pytalloc_get_mem_ctx(obj), object->in.dwTypeId, &object->in.pData, "union DNSSRV_RPC_UNION");
   27356           0 :         if (py_pData == NULL) {
   27357           0 :                 return NULL;
   27358             :         }
   27359           0 :         return py_pData;
   27360             : }
   27361             : 
   27362           0 : static int py_DnssrvOperation_in_set_pData(PyObject *py_obj, PyObject *value, void *closure)
   27363             : {
   27364           0 :         struct DnssrvOperation *object = pytalloc_get_ptr(py_obj);
   27365           0 :         if (value == NULL) {
   27366           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pData");
   27367           0 :                 return -1;
   27368             :         }
   27369             :         {
   27370           0 :                 union DNSSRV_RPC_UNION *pData_switch_0;
   27371           0 :                 pData_switch_0 = (union DNSSRV_RPC_UNION *)pyrpc_export_union(&DNSSRV_RPC_UNION_Type, pytalloc_get_mem_ctx(py_obj), object->in.dwTypeId, value, "union DNSSRV_RPC_UNION");
   27372           0 :                 if (pData_switch_0 == NULL) {
   27373           0 :                         return -1;
   27374             :                 }
   27375           0 :                 object->in.pData = *pData_switch_0;
   27376             :         }
   27377           0 :         return 0;
   27378             : }
   27379             : 
   27380           0 : static PyObject *py_DnssrvOperation_get_result(PyObject *obj, void *closure)
   27381             : {
   27382           0 :         struct DnssrvOperation *object = pytalloc_get_ptr(obj);
   27383           0 :         PyObject *py_result;
   27384           0 :         py_result = PyErr_FromWERROR(object->out.result);
   27385           0 :         return py_result;
   27386             : }
   27387             : 
   27388           0 : static int py_DnssrvOperation_set_result(PyObject *py_obj, PyObject *value, void *closure)
   27389             : {
   27390           0 :         struct DnssrvOperation *object = pytalloc_get_ptr(py_obj);
   27391           0 :         if (value == NULL) {
   27392           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.result");
   27393           0 :                 return -1;
   27394             :         }
   27395           0 :         object->out.result = W_ERROR(PyLong_AsLong(value));
   27396           0 :         return 0;
   27397             : }
   27398             : 
   27399             : static PyGetSetDef py_DnssrvOperation_getsetters[] = {
   27400             :         {
   27401             :                 .name = discard_const_p(char, "in_pwszServerName"),
   27402             :                 .get = py_DnssrvOperation_in_get_pwszServerName,
   27403             :                 .set = py_DnssrvOperation_in_set_pwszServerName,
   27404             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
   27405             :         },
   27406             :         {
   27407             :                 .name = discard_const_p(char, "in_pszZone"),
   27408             :                 .get = py_DnssrvOperation_in_get_pszZone,
   27409             :                 .set = py_DnssrvOperation_in_set_pszZone,
   27410             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   27411             :         },
   27412             :         {
   27413             :                 .name = discard_const_p(char, "in_dwContext"),
   27414             :                 .get = py_DnssrvOperation_in_get_dwContext,
   27415             :                 .set = py_DnssrvOperation_in_set_dwContext,
   27416             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   27417             :         },
   27418             :         {
   27419             :                 .name = discard_const_p(char, "in_pszOperation"),
   27420             :                 .get = py_DnssrvOperation_in_get_pszOperation,
   27421             :                 .set = py_DnssrvOperation_in_set_pszOperation,
   27422             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   27423             :         },
   27424             :         {
   27425             :                 .name = discard_const_p(char, "in_dwTypeId"),
   27426             :                 .get = py_DnssrvOperation_in_get_dwTypeId,
   27427             :                 .set = py_DnssrvOperation_in_set_dwTypeId,
   27428             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_TYPEID")
   27429             :         },
   27430             :         {
   27431             :                 .name = discard_const_p(char, "in_pData"),
   27432             :                 .get = py_DnssrvOperation_in_get_pData,
   27433             :                 .set = py_DnssrvOperation_in_set_pData,
   27434             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNSSRV_RPC_UNION")
   27435             :         },
   27436             :         {
   27437             :                 .name = discard_const_p(char, "result"),
   27438             :                 .get = py_DnssrvOperation_get_result,
   27439             :                 .set = py_DnssrvOperation_set_result,
   27440             :                 .doc = discard_const_p(char, "PIDL-generated element of type WERROR")
   27441             :         },
   27442             :         { .name = NULL }
   27443             : };
   27444             : 
   27445           0 : static PyObject *py_DnssrvOperation_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   27446             : {
   27447           0 :         PyObject *self = pytalloc_new(struct DnssrvOperation, type);
   27448           0 :         return self;
   27449             : }
   27450             : 
   27451           0 : static PyObject *py_DnssrvOperation_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
   27452             : {
   27453             : 
   27454             : 
   27455           0 :         return PyLong_FromLong(0);
   27456             : }
   27457             : 
   27458           0 : static PyObject *py_DnssrvOperation_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
   27459             : {
   27460           0 :         const struct ndr_interface_call *call = NULL;
   27461           0 :         struct DnssrvOperation *object = pytalloc_get_ptr(py_obj);
   27462           0 :         PyObject *ret = NULL;
   27463           0 :         struct ndr_push *push = NULL;
   27464           0 :         DATA_BLOB blob;
   27465           0 :         enum ndr_err_code err;
   27466             : 
   27467           0 :         if (ndr_table_dnsserver.num_calls < 1) {
   27468           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvOperation_ndr_pack");
   27469           0 :                 return NULL;
   27470             :         }
   27471           0 :         call = &ndr_table_dnsserver.calls[0];
   27472             : 
   27473           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
   27474           0 :         if (push == NULL) {
   27475           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
   27476           0 :                 return NULL;
   27477             :         }
   27478             : 
   27479           0 :         push->flags |= ndr_push_flags;
   27480             : 
   27481           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
   27482           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   27483           0 :                 TALLOC_FREE(push);
   27484           0 :                 PyErr_SetNdrError(err);
   27485           0 :                 return NULL;
   27486             :         }
   27487           0 :         blob = ndr_push_blob(push);
   27488           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
   27489           0 :         TALLOC_FREE(push);
   27490           0 :         return ret;
   27491             : }
   27492             : 
   27493           0 : static PyObject *py_DnssrvOperation_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   27494             : {
   27495           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
   27496           0 :         PyObject *bigendian_obj = NULL;
   27497           0 :         PyObject *ndr64_obj = NULL;
   27498           0 :         libndr_flags ndr_push_flags = 0;
   27499             : 
   27500           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
   27501             :                 discard_const_p(char *, kwnames),
   27502             :                 &bigendian_obj,
   27503             :                 &ndr64_obj)) {
   27504           0 :                 return NULL;
   27505             :         }
   27506             : 
   27507           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   27508           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
   27509             :         }
   27510           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   27511           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
   27512             :         }
   27513             : 
   27514           0 :         return py_DnssrvOperation_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
   27515             : }
   27516             : 
   27517           0 : static PyObject *py_DnssrvOperation_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   27518             : {
   27519           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
   27520           0 :         PyObject *bigendian_obj = NULL;
   27521           0 :         PyObject *ndr64_obj = NULL;
   27522           0 :         libndr_flags ndr_push_flags = 0;
   27523             : 
   27524           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
   27525             :                 discard_const_p(char *, kwnames),
   27526             :                 &bigendian_obj,
   27527             :                 &ndr64_obj)) {
   27528           0 :                 return NULL;
   27529             :         }
   27530             : 
   27531           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   27532           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
   27533             :         }
   27534           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   27535           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
   27536             :         }
   27537             : 
   27538           0 :         return py_DnssrvOperation_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
   27539             : }
   27540             : 
   27541           0 : static PyObject *py_DnssrvOperation_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
   27542             : {
   27543           0 :         const struct ndr_interface_call *call = NULL;
   27544           0 :         struct DnssrvOperation *object = pytalloc_get_ptr(py_obj);
   27545           0 :         struct ndr_pull *pull = NULL;
   27546           0 :         enum ndr_err_code err;
   27547             : 
   27548           0 :         if (ndr_table_dnsserver.num_calls < 1) {
   27549           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvOperation_ndr_unpack");
   27550           0 :                 return NULL;
   27551             :         }
   27552           0 :         call = &ndr_table_dnsserver.calls[0];
   27553             : 
   27554           0 :         pull = ndr_pull_init_blob(blob, object);
   27555           0 :         if (pull == NULL) {
   27556           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
   27557           0 :                 return NULL;
   27558             :         }
   27559             : 
   27560           0 :         pull->flags |= ndr_pull_flags;
   27561             : 
   27562           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
   27563           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   27564           0 :                 TALLOC_FREE(pull);
   27565           0 :                 PyErr_SetNdrError(err);
   27566           0 :                 return NULL;
   27567             :         }
   27568           0 :         if (!allow_remaining) {
   27569           0 :                 uint32_t highest_ofs;
   27570             : 
   27571           0 :                 if (pull->offset > pull->relative_highest_offset) {
   27572           0 :                         highest_ofs = pull->offset;
   27573             :                 } else {
   27574           0 :                         highest_ofs = pull->relative_highest_offset;
   27575             :                 }
   27576           0 :                 if (highest_ofs < pull->data_size) {
   27577           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
   27578             :                                 "not all bytes consumed ofs[%u] size[%u]",
   27579             :                                 highest_ofs, pull->data_size);
   27580           0 :                         TALLOC_FREE(pull);
   27581           0 :                         PyErr_SetNdrError(err);
   27582           0 :                         return NULL;
   27583             :                 }
   27584             :         }
   27585             : 
   27586           0 :         TALLOC_FREE(pull);
   27587           0 :         Py_RETURN_NONE;
   27588             : }
   27589             : 
   27590           0 : static PyObject *py_DnssrvOperation_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   27591             : {
   27592           0 :         DATA_BLOB blob;
   27593           0 :         Py_ssize_t blob_length = 0;
   27594           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
   27595           0 :         PyObject *bigendian_obj = NULL;
   27596           0 :         PyObject *ndr64_obj = NULL;
   27597           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
   27598           0 :         PyObject *allow_remaining_obj = NULL;
   27599           0 :         bool allow_remaining = false;
   27600             : 
   27601           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
   27602             :                 discard_const_p(char *, kwnames),
   27603             :                 &blob.data, &blob_length,
   27604             :                 &bigendian_obj,
   27605             :                 &ndr64_obj,
   27606             :                 &allow_remaining_obj)) {
   27607           0 :                 return NULL;
   27608             :         }
   27609           0 :         blob.length = blob_length;
   27610             : 
   27611           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   27612           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
   27613             :         }
   27614           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   27615           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
   27616             :         }
   27617             : 
   27618           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
   27619           0 :                 allow_remaining = true;
   27620             :         }
   27621             : 
   27622           0 :         return py_DnssrvOperation_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
   27623             : }
   27624             : 
   27625           0 : static PyObject *py_DnssrvOperation_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   27626             : {
   27627           0 :         DATA_BLOB blob;
   27628           0 :         Py_ssize_t blob_length = 0;
   27629           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
   27630           0 :         PyObject *bigendian_obj = NULL;
   27631           0 :         PyObject *ndr64_obj = NULL;
   27632           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
   27633           0 :         PyObject *allow_remaining_obj = NULL;
   27634           0 :         bool allow_remaining = false;
   27635             : 
   27636           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
   27637             :                 discard_const_p(char *, kwnames),
   27638             :                 &blob.data, &blob_length,
   27639             :                 &bigendian_obj,
   27640             :                 &ndr64_obj,
   27641             :                 &allow_remaining_obj)) {
   27642           0 :                 return NULL;
   27643             :         }
   27644           0 :         blob.length = blob_length;
   27645             : 
   27646           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   27647           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
   27648             :         }
   27649           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   27650           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
   27651             :         }
   27652             : 
   27653           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
   27654           0 :                 allow_remaining = true;
   27655             :         }
   27656             : 
   27657           0 :         return py_DnssrvOperation_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
   27658             : }
   27659             : 
   27660           0 : static PyObject *py_DnssrvOperation_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
   27661             : {
   27662           0 :         const struct ndr_interface_call *call = NULL;
   27663           0 :         struct DnssrvOperation *object = pytalloc_get_ptr(py_obj);
   27664           0 :         PyObject *ret;
   27665           0 :         char *retstr;
   27666             : 
   27667           0 :         if (ndr_table_dnsserver.num_calls < 1) {
   27668           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvOperation_ndr_print");
   27669           0 :                 return NULL;
   27670             :         }
   27671           0 :         call = &ndr_table_dnsserver.calls[0];
   27672             : 
   27673           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
   27674           0 :         ret = PyUnicode_FromString(retstr);
   27675           0 :         TALLOC_FREE(retstr);
   27676             : 
   27677           0 :         return ret;
   27678             : }
   27679             : 
   27680           0 : static PyObject *py_DnssrvOperation_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
   27681             : {
   27682           0 :         return py_DnssrvOperation_ndr_print(py_obj, "DnssrvOperation_in", NDR_IN);
   27683             : }
   27684             : 
   27685           0 : static PyObject *py_DnssrvOperation_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
   27686             : {
   27687           0 :         return py_DnssrvOperation_ndr_print(py_obj, "DnssrvOperation_out", NDR_OUT);
   27688             : }
   27689             : 
   27690             : static PyMethodDef py_DnssrvOperation_methods[] = {
   27691             :         { "opnum", (PyCFunction)py_DnssrvOperation_ndr_opnum, METH_NOARGS|METH_CLASS,
   27692             :                 "dnsserver.DnssrvOperation.opnum() -> 0 (0x00) " },
   27693             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvOperation_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
   27694             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
   27695             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvOperation_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
   27696             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
   27697             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvOperation_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
   27698             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
   27699             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvOperation_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
   27700             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
   27701             :         { "__ndr_print_in__", (PyCFunction)py_DnssrvOperation_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
   27702             :         { "__ndr_print_out__", (PyCFunction)py_DnssrvOperation_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
   27703             :         { NULL, NULL, 0, NULL }
   27704             : };
   27705             : 
   27706             : 
   27707             : static PyTypeObject DnssrvOperation_Type = {
   27708             :         PyVarObject_HEAD_INIT(NULL, 0)
   27709             :         .tp_name = "dnsserver.DnssrvOperation",
   27710             :         .tp_getset = py_DnssrvOperation_getsetters,
   27711             :         .tp_methods = py_DnssrvOperation_methods,
   27712             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   27713             :         .tp_new = py_DnssrvOperation_new,
   27714             : };
   27715             : 
   27716           3 : static bool pack_py_DnssrvOperation_args_in(PyObject *args, PyObject *kwargs, struct DnssrvOperation *r)
   27717             : {
   27718           0 :         PyObject *py_pwszServerName;
   27719           0 :         PyObject *py_pszZone;
   27720           0 :         PyObject *py_dwContext;
   27721           0 :         PyObject *py_pszOperation;
   27722           0 :         PyObject *py_dwTypeId;
   27723           0 :         PyObject *py_pData;
   27724           3 :         const char *kwnames[] = {
   27725             :                 "pwszServerName", "pszZone", "dwContext", "pszOperation", "dwTypeId", "pData", NULL
   27726             :         };
   27727             : 
   27728           3 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:DnssrvOperation", discard_const_p(char *, kwnames), &py_pwszServerName, &py_pszZone, &py_dwContext, &py_pszOperation, &py_dwTypeId, &py_pData)) {
   27729           0 :                 return false;
   27730             :         }
   27731             : 
   27732           3 :         if (py_pwszServerName == NULL) {
   27733           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pwszServerName");
   27734           0 :                 return false;
   27735             :         }
   27736           3 :         if (py_pwszServerName == Py_None) {
   27737           0 :                 r->in.pwszServerName = NULL;
   27738             :         } else {
   27739           3 :                 r->in.pwszServerName = NULL;
   27740             :                 {
   27741           0 :                         const char *test_str;
   27742           0 :                         const char *talloc_str;
   27743           3 :                         PyObject *unicode = NULL;
   27744           3 :                         if (PyUnicode_Check(py_pwszServerName)) {
   27745           3 :                                 unicode = PyUnicode_AsEncodedString(py_pwszServerName, "utf-8", "ignore");
   27746           3 :                                 if (unicode == NULL) {
   27747           0 :                                         return false;
   27748             :                                 }
   27749           3 :                                 test_str = PyBytes_AS_STRING(unicode);
   27750           0 :                         } else if (PyBytes_Check(py_pwszServerName)) {
   27751           0 :                                 test_str = PyBytes_AS_STRING(py_pwszServerName);
   27752             :                         } else {
   27753           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pwszServerName)->tp_name);
   27754           0 :                                 return false;
   27755             :                         }
   27756           3 :                         talloc_str = talloc_strdup(r, test_str);
   27757           3 :                         if (unicode != NULL) {
   27758           2 :                                 Py_DECREF(unicode);
   27759             :                         }
   27760           3 :                         if (talloc_str == NULL) {
   27761           0 :                                 PyErr_NoMemory();
   27762           0 :                                 return false;
   27763             :                         }
   27764           3 :                         r->in.pwszServerName = talloc_str;
   27765             :                 }
   27766             :         }
   27767           3 :         if (py_pszZone == NULL) {
   27768           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszZone");
   27769           0 :                 return false;
   27770             :         }
   27771           3 :         if (py_pszZone == Py_None) {
   27772           0 :                 r->in.pszZone = NULL;
   27773             :         } else {
   27774           3 :                 r->in.pszZone = NULL;
   27775             :                 {
   27776           0 :                         const char *test_str;
   27777           0 :                         const char *talloc_str;
   27778           3 :                         PyObject *unicode = NULL;
   27779           3 :                         if (PyUnicode_Check(py_pszZone)) {
   27780           3 :                                 unicode = PyUnicode_AsEncodedString(py_pszZone, "utf-8", "ignore");
   27781           3 :                                 if (unicode == NULL) {
   27782           0 :                                         return false;
   27783             :                                 }
   27784           3 :                                 test_str = PyBytes_AS_STRING(unicode);
   27785           0 :                         } else if (PyBytes_Check(py_pszZone)) {
   27786           0 :                                 test_str = PyBytes_AS_STRING(py_pszZone);
   27787             :                         } else {
   27788           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszZone)->tp_name);
   27789           0 :                                 return false;
   27790             :                         }
   27791           3 :                         talloc_str = talloc_strdup(r, test_str);
   27792           3 :                         if (unicode != NULL) {
   27793           2 :                                 Py_DECREF(unicode);
   27794             :                         }
   27795           3 :                         if (talloc_str == NULL) {
   27796           0 :                                 PyErr_NoMemory();
   27797           0 :                                 return false;
   27798             :                         }
   27799           3 :                         r->in.pszZone = talloc_str;
   27800             :                 }
   27801             :         }
   27802           3 :         if (py_dwContext == NULL) {
   27803           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.dwContext");
   27804           0 :                 return false;
   27805             :         }
   27806             :         {
   27807           3 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.dwContext));
   27808           3 :                 if (PyLong_Check(py_dwContext)) {
   27809           0 :                         unsigned long long test_var;
   27810           3 :                         test_var = PyLong_AsUnsignedLongLong(py_dwContext);
   27811           3 :                         if (PyErr_Occurred() != NULL) {
   27812           0 :                                 return false;
   27813             :                         }
   27814           3 :                         if (test_var > uint_max) {
   27815           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   27816             :                                   PyLong_Type.tp_name, uint_max, test_var);
   27817           0 :                                 return false;
   27818             :                         }
   27819           3 :                         r->in.dwContext = test_var;
   27820             :                 } else {
   27821           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   27822             :                           PyLong_Type.tp_name);
   27823           0 :                         return false;
   27824             :                 }
   27825             :         }
   27826           3 :         if (py_pszOperation == NULL) {
   27827           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszOperation");
   27828           0 :                 return false;
   27829             :         }
   27830           3 :         if (py_pszOperation == Py_None) {
   27831           0 :                 r->in.pszOperation = NULL;
   27832             :         } else {
   27833           3 :                 r->in.pszOperation = NULL;
   27834             :                 {
   27835           0 :                         const char *test_str;
   27836           0 :                         const char *talloc_str;
   27837           3 :                         PyObject *unicode = NULL;
   27838           3 :                         if (PyUnicode_Check(py_pszOperation)) {
   27839           3 :                                 unicode = PyUnicode_AsEncodedString(py_pszOperation, "utf-8", "ignore");
   27840           3 :                                 if (unicode == NULL) {
   27841           0 :                                         return false;
   27842             :                                 }
   27843           3 :                                 test_str = PyBytes_AS_STRING(unicode);
   27844           0 :                         } else if (PyBytes_Check(py_pszOperation)) {
   27845           0 :                                 test_str = PyBytes_AS_STRING(py_pszOperation);
   27846             :                         } else {
   27847           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszOperation)->tp_name);
   27848           0 :                                 return false;
   27849             :                         }
   27850           3 :                         talloc_str = talloc_strdup(r, test_str);
   27851           3 :                         if (unicode != NULL) {
   27852           2 :                                 Py_DECREF(unicode);
   27853             :                         }
   27854           3 :                         if (talloc_str == NULL) {
   27855           0 :                                 PyErr_NoMemory();
   27856           0 :                                 return false;
   27857             :                         }
   27858           3 :                         r->in.pszOperation = talloc_str;
   27859             :                 }
   27860             :         }
   27861           3 :         if (py_dwTypeId == NULL) {
   27862           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.dwTypeId");
   27863           0 :                 return false;
   27864             :         }
   27865             :         {
   27866           3 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.dwTypeId));
   27867           3 :                 if (PyLong_Check(py_dwTypeId)) {
   27868           0 :                         unsigned long long test_var;
   27869           3 :                         test_var = PyLong_AsUnsignedLongLong(py_dwTypeId);
   27870           3 :                         if (PyErr_Occurred() != NULL) {
   27871           0 :                                 return false;
   27872             :                         }
   27873           3 :                         if (test_var > uint_max) {
   27874           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   27875             :                                   PyLong_Type.tp_name, uint_max, test_var);
   27876           0 :                                 return false;
   27877             :                         }
   27878           3 :                         r->in.dwTypeId = test_var;
   27879             :                 } else {
   27880           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   27881             :                           PyLong_Type.tp_name);
   27882           0 :                         return false;
   27883             :                 }
   27884             :         }
   27885           3 :         if (py_pData == NULL) {
   27886           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pData");
   27887           0 :                 return false;
   27888             :         }
   27889             :         {
   27890           0 :                 union DNSSRV_RPC_UNION *pData_switch_0;
   27891           3 :                 pData_switch_0 = (union DNSSRV_RPC_UNION *)pyrpc_export_union(&DNSSRV_RPC_UNION_Type, r, r->in.dwTypeId, py_pData, "union DNSSRV_RPC_UNION");
   27892           3 :                 if (pData_switch_0 == NULL) {
   27893           0 :                         return false;
   27894             :                 }
   27895           3 :                 r->in.pData = *pData_switch_0;
   27896             :         }
   27897           3 :         return true;
   27898             : }
   27899             : 
   27900           3 : static PyObject *unpack_py_DnssrvOperation_args_out(struct DnssrvOperation *r)
   27901             : {
   27902           0 :         PyObject *result;
   27903           3 :         result = Py_None;
   27904           2 :         Py_INCREF(result);
   27905           3 :         if (!W_ERROR_IS_OK(r->out.result)) {
   27906           3 :                 PyErr_SetWERROR(r->out.result);
   27907           3 :                 return NULL;
   27908             :         }
   27909             : 
   27910           0 :         return result;
   27911             : }
   27912             : 
   27913             : 
   27914           0 : static PyObject *py_DnssrvQuery_in_get_pwszServerName(PyObject *obj, void *closure)
   27915             : {
   27916           0 :         struct DnssrvQuery *object = pytalloc_get_ptr(obj);
   27917           0 :         PyObject *py_pwszServerName;
   27918           0 :         if (object->in.pwszServerName == NULL) {
   27919           0 :                 Py_RETURN_NONE;
   27920             :         }
   27921           0 :         if (object->in.pwszServerName == NULL) {
   27922           0 :                 py_pwszServerName = Py_None;
   27923           0 :                 Py_INCREF(py_pwszServerName);
   27924             :         } else {
   27925           0 :                 if (object->in.pwszServerName == NULL) {
   27926           0 :                         py_pwszServerName = Py_None;
   27927           0 :                         Py_INCREF(py_pwszServerName);
   27928             :                 } else {
   27929           0 :                         py_pwszServerName = PyUnicode_Decode(object->in.pwszServerName, strlen(object->in.pwszServerName), "utf-8", "ignore");
   27930             :                 }
   27931             :         }
   27932           0 :         return py_pwszServerName;
   27933             : }
   27934             : 
   27935           0 : static int py_DnssrvQuery_in_set_pwszServerName(PyObject *py_obj, PyObject *value, void *closure)
   27936             : {
   27937           0 :         struct DnssrvQuery *object = pytalloc_get_ptr(py_obj);
   27938           0 :         if (value == NULL) {
   27939           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pwszServerName");
   27940           0 :                 return -1;
   27941             :         }
   27942           0 :         if (value == Py_None) {
   27943           0 :                 object->in.pwszServerName = NULL;
   27944             :         } else {
   27945           0 :                 object->in.pwszServerName = NULL;
   27946             :                 {
   27947           0 :                         const char *test_str;
   27948           0 :                         const char *talloc_str;
   27949           0 :                         PyObject *unicode = NULL;
   27950           0 :                         if (PyUnicode_Check(value)) {
   27951           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   27952           0 :                                 if (unicode == NULL) {
   27953           0 :                                         return -1;
   27954             :                                 }
   27955           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   27956           0 :                         } else if (PyBytes_Check(value)) {
   27957           0 :                                 test_str = PyBytes_AS_STRING(value);
   27958             :                         } else {
   27959           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   27960           0 :                                 return -1;
   27961             :                         }
   27962           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   27963           0 :                         if (unicode != NULL) {
   27964           0 :                                 Py_DECREF(unicode);
   27965             :                         }
   27966           0 :                         if (talloc_str == NULL) {
   27967           0 :                                 PyErr_NoMemory();
   27968           0 :                                 return -1;
   27969             :                         }
   27970           0 :                         object->in.pwszServerName = talloc_str;
   27971             :                 }
   27972             :         }
   27973           0 :         return 0;
   27974             : }
   27975             : 
   27976           0 : static PyObject *py_DnssrvQuery_in_get_pszZone(PyObject *obj, void *closure)
   27977             : {
   27978           0 :         struct DnssrvQuery *object = pytalloc_get_ptr(obj);
   27979           0 :         PyObject *py_pszZone;
   27980           0 :         if (object->in.pszZone == NULL) {
   27981           0 :                 Py_RETURN_NONE;
   27982             :         }
   27983           0 :         if (object->in.pszZone == NULL) {
   27984           0 :                 py_pszZone = Py_None;
   27985           0 :                 Py_INCREF(py_pszZone);
   27986             :         } else {
   27987           0 :                 if (object->in.pszZone == NULL) {
   27988           0 :                         py_pszZone = Py_None;
   27989           0 :                         Py_INCREF(py_pszZone);
   27990             :                 } else {
   27991           0 :                         py_pszZone = PyUnicode_Decode(object->in.pszZone, strlen(object->in.pszZone), "utf-8", "ignore");
   27992             :                 }
   27993             :         }
   27994           0 :         return py_pszZone;
   27995             : }
   27996             : 
   27997           0 : static int py_DnssrvQuery_in_set_pszZone(PyObject *py_obj, PyObject *value, void *closure)
   27998             : {
   27999           0 :         struct DnssrvQuery *object = pytalloc_get_ptr(py_obj);
   28000           0 :         if (value == NULL) {
   28001           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszZone");
   28002           0 :                 return -1;
   28003             :         }
   28004           0 :         if (value == Py_None) {
   28005           0 :                 object->in.pszZone = NULL;
   28006             :         } else {
   28007           0 :                 object->in.pszZone = NULL;
   28008             :                 {
   28009           0 :                         const char *test_str;
   28010           0 :                         const char *talloc_str;
   28011           0 :                         PyObject *unicode = NULL;
   28012           0 :                         if (PyUnicode_Check(value)) {
   28013           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   28014           0 :                                 if (unicode == NULL) {
   28015           0 :                                         return -1;
   28016             :                                 }
   28017           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   28018           0 :                         } else if (PyBytes_Check(value)) {
   28019           0 :                                 test_str = PyBytes_AS_STRING(value);
   28020             :                         } else {
   28021           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   28022           0 :                                 return -1;
   28023             :                         }
   28024           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   28025           0 :                         if (unicode != NULL) {
   28026           0 :                                 Py_DECREF(unicode);
   28027             :                         }
   28028           0 :                         if (talloc_str == NULL) {
   28029           0 :                                 PyErr_NoMemory();
   28030           0 :                                 return -1;
   28031             :                         }
   28032           0 :                         object->in.pszZone = talloc_str;
   28033             :                 }
   28034             :         }
   28035           0 :         return 0;
   28036             : }
   28037             : 
   28038           0 : static PyObject *py_DnssrvQuery_in_get_pszOperation(PyObject *obj, void *closure)
   28039             : {
   28040           0 :         struct DnssrvQuery *object = pytalloc_get_ptr(obj);
   28041           0 :         PyObject *py_pszOperation;
   28042           0 :         if (object->in.pszOperation == NULL) {
   28043           0 :                 Py_RETURN_NONE;
   28044             :         }
   28045           0 :         if (object->in.pszOperation == NULL) {
   28046           0 :                 py_pszOperation = Py_None;
   28047           0 :                 Py_INCREF(py_pszOperation);
   28048             :         } else {
   28049           0 :                 if (object->in.pszOperation == NULL) {
   28050           0 :                         py_pszOperation = Py_None;
   28051           0 :                         Py_INCREF(py_pszOperation);
   28052             :                 } else {
   28053           0 :                         py_pszOperation = PyUnicode_Decode(object->in.pszOperation, strlen(object->in.pszOperation), "utf-8", "ignore");
   28054             :                 }
   28055             :         }
   28056           0 :         return py_pszOperation;
   28057             : }
   28058             : 
   28059           0 : static int py_DnssrvQuery_in_set_pszOperation(PyObject *py_obj, PyObject *value, void *closure)
   28060             : {
   28061           0 :         struct DnssrvQuery *object = pytalloc_get_ptr(py_obj);
   28062           0 :         if (value == NULL) {
   28063           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszOperation");
   28064           0 :                 return -1;
   28065             :         }
   28066           0 :         if (value == Py_None) {
   28067           0 :                 object->in.pszOperation = NULL;
   28068             :         } else {
   28069           0 :                 object->in.pszOperation = NULL;
   28070             :                 {
   28071           0 :                         const char *test_str;
   28072           0 :                         const char *talloc_str;
   28073           0 :                         PyObject *unicode = NULL;
   28074           0 :                         if (PyUnicode_Check(value)) {
   28075           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   28076           0 :                                 if (unicode == NULL) {
   28077           0 :                                         return -1;
   28078             :                                 }
   28079           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   28080           0 :                         } else if (PyBytes_Check(value)) {
   28081           0 :                                 test_str = PyBytes_AS_STRING(value);
   28082             :                         } else {
   28083           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   28084           0 :                                 return -1;
   28085             :                         }
   28086           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   28087           0 :                         if (unicode != NULL) {
   28088           0 :                                 Py_DECREF(unicode);
   28089             :                         }
   28090           0 :                         if (talloc_str == NULL) {
   28091           0 :                                 PyErr_NoMemory();
   28092           0 :                                 return -1;
   28093             :                         }
   28094           0 :                         object->in.pszOperation = talloc_str;
   28095             :                 }
   28096             :         }
   28097           0 :         return 0;
   28098             : }
   28099             : 
   28100           0 : static PyObject *py_DnssrvQuery_out_get_pdwTypeId(PyObject *obj, void *closure)
   28101             : {
   28102           0 :         struct DnssrvQuery *object = pytalloc_get_ptr(obj);
   28103           0 :         PyObject *py_pdwTypeId;
   28104           0 :         if (object->out.pdwTypeId == NULL) {
   28105           0 :                 Py_RETURN_NONE;
   28106             :         }
   28107           0 :         py_pdwTypeId = PyLong_FromUnsignedLongLong((uint32_t)(*object->out.pdwTypeId));
   28108           0 :         return py_pdwTypeId;
   28109             : }
   28110             : 
   28111           0 : static int py_DnssrvQuery_out_set_pdwTypeId(PyObject *py_obj, PyObject *value, void *closure)
   28112             : {
   28113           0 :         struct DnssrvQuery *object = pytalloc_get_ptr(py_obj);
   28114           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.pdwTypeId));
   28115           0 :         if (value == NULL) {
   28116           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.pdwTypeId");
   28117           0 :                 return -1;
   28118             :         }
   28119           0 :         object->out.pdwTypeId = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.pdwTypeId);
   28120           0 :         if (object->out.pdwTypeId == NULL) {
   28121           0 :                 PyErr_NoMemory();
   28122           0 :                 return -1;
   28123             :         }
   28124             :         {
   28125           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->out.pdwTypeId));
   28126           0 :                 if (PyLong_Check(value)) {
   28127           0 :                         unsigned long long test_var;
   28128           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   28129           0 :                         if (PyErr_Occurred() != NULL) {
   28130           0 :                                 return -1;
   28131             :                         }
   28132           0 :                         if (test_var > uint_max) {
   28133           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   28134             :                                   PyLong_Type.tp_name, uint_max, test_var);
   28135           0 :                                 return -1;
   28136             :                         }
   28137           0 :                         *object->out.pdwTypeId = test_var;
   28138             :                 } else {
   28139           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   28140             :                           PyLong_Type.tp_name);
   28141           0 :                         return -1;
   28142             :                 }
   28143             :         }
   28144           0 :         return 0;
   28145             : }
   28146             : 
   28147           0 : static PyObject *py_DnssrvQuery_out_get_ppData(PyObject *obj, void *closure)
   28148             : {
   28149           0 :         struct DnssrvQuery *object = pytalloc_get_ptr(obj);
   28150           0 :         PyObject *py_ppData;
   28151           0 :         if (object->out.ppData == NULL) {
   28152           0 :                 Py_RETURN_NONE;
   28153             :         }
   28154           0 :         py_ppData = pyrpc_import_union(&DNSSRV_RPC_UNION_Type, object->out.ppData, *object->out.pdwTypeId, object->out.ppData, "union DNSSRV_RPC_UNION");
   28155           0 :         if (py_ppData == NULL) {
   28156           0 :                 return NULL;
   28157             :         }
   28158           0 :         return py_ppData;
   28159             : }
   28160             : 
   28161           0 : static int py_DnssrvQuery_out_set_ppData(PyObject *py_obj, PyObject *value, void *closure)
   28162             : {
   28163           0 :         struct DnssrvQuery *object = pytalloc_get_ptr(py_obj);
   28164           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.ppData));
   28165           0 :         if (value == NULL) {
   28166           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.ppData");
   28167           0 :                 return -1;
   28168             :         }
   28169           0 :         object->out.ppData = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.ppData);
   28170           0 :         if (object->out.ppData == NULL) {
   28171           0 :                 PyErr_NoMemory();
   28172           0 :                 return -1;
   28173             :         }
   28174             :         {
   28175           0 :                 union DNSSRV_RPC_UNION *ppData_switch_1;
   28176           0 :                 ppData_switch_1 = (union DNSSRV_RPC_UNION *)pyrpc_export_union(&DNSSRV_RPC_UNION_Type, pytalloc_get_mem_ctx(py_obj), *object->out.pdwTypeId, value, "union DNSSRV_RPC_UNION");
   28177           0 :                 if (ppData_switch_1 == NULL) {
   28178           0 :                         return -1;
   28179             :                 }
   28180           0 :                 object->out.ppData = ppData_switch_1;
   28181             :         }
   28182           0 :         return 0;
   28183             : }
   28184             : 
   28185           0 : static PyObject *py_DnssrvQuery_get_result(PyObject *obj, void *closure)
   28186             : {
   28187           0 :         struct DnssrvQuery *object = pytalloc_get_ptr(obj);
   28188           0 :         PyObject *py_result;
   28189           0 :         py_result = PyErr_FromWERROR(object->out.result);
   28190           0 :         return py_result;
   28191             : }
   28192             : 
   28193           0 : static int py_DnssrvQuery_set_result(PyObject *py_obj, PyObject *value, void *closure)
   28194             : {
   28195           0 :         struct DnssrvQuery *object = pytalloc_get_ptr(py_obj);
   28196           0 :         if (value == NULL) {
   28197           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.result");
   28198           0 :                 return -1;
   28199             :         }
   28200           0 :         object->out.result = W_ERROR(PyLong_AsLong(value));
   28201           0 :         return 0;
   28202             : }
   28203             : 
   28204             : static PyGetSetDef py_DnssrvQuery_getsetters[] = {
   28205             :         {
   28206             :                 .name = discard_const_p(char, "in_pwszServerName"),
   28207             :                 .get = py_DnssrvQuery_in_get_pwszServerName,
   28208             :                 .set = py_DnssrvQuery_in_set_pwszServerName,
   28209             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
   28210             :         },
   28211             :         {
   28212             :                 .name = discard_const_p(char, "in_pszZone"),
   28213             :                 .get = py_DnssrvQuery_in_get_pszZone,
   28214             :                 .set = py_DnssrvQuery_in_set_pszZone,
   28215             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   28216             :         },
   28217             :         {
   28218             :                 .name = discard_const_p(char, "in_pszOperation"),
   28219             :                 .get = py_DnssrvQuery_in_get_pszOperation,
   28220             :                 .set = py_DnssrvQuery_in_set_pszOperation,
   28221             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   28222             :         },
   28223             :         {
   28224             :                 .name = discard_const_p(char, "out_pdwTypeId"),
   28225             :                 .get = py_DnssrvQuery_out_get_pdwTypeId,
   28226             :                 .set = py_DnssrvQuery_out_set_pdwTypeId,
   28227             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_TYPEID")
   28228             :         },
   28229             :         {
   28230             :                 .name = discard_const_p(char, "out_ppData"),
   28231             :                 .get = py_DnssrvQuery_out_get_ppData,
   28232             :                 .set = py_DnssrvQuery_out_set_ppData,
   28233             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNSSRV_RPC_UNION")
   28234             :         },
   28235             :         {
   28236             :                 .name = discard_const_p(char, "result"),
   28237             :                 .get = py_DnssrvQuery_get_result,
   28238             :                 .set = py_DnssrvQuery_set_result,
   28239             :                 .doc = discard_const_p(char, "PIDL-generated element of type WERROR")
   28240             :         },
   28241             :         { .name = NULL }
   28242             : };
   28243             : 
   28244           0 : static PyObject *py_DnssrvQuery_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   28245             : {
   28246           0 :         PyObject *self = pytalloc_new(struct DnssrvQuery, type);
   28247           0 :         struct DnssrvQuery *_self = (struct DnssrvQuery *)pytalloc_get_ptr(self);
   28248           0 :         TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
   28249           0 :         _self->out.pdwTypeId = talloc_zero(mem_ctx, enum DNS_RPC_TYPEID);
   28250           0 :         _self->out.ppData = talloc_zero(mem_ctx, union DNSSRV_RPC_UNION);
   28251           0 :         return self;
   28252             : }
   28253             : 
   28254           0 : static PyObject *py_DnssrvQuery_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
   28255             : {
   28256             : 
   28257             : 
   28258           0 :         return PyLong_FromLong(1);
   28259             : }
   28260             : 
   28261           0 : static PyObject *py_DnssrvQuery_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
   28262             : {
   28263           0 :         const struct ndr_interface_call *call = NULL;
   28264           0 :         struct DnssrvQuery *object = pytalloc_get_ptr(py_obj);
   28265           0 :         PyObject *ret = NULL;
   28266           0 :         struct ndr_push *push = NULL;
   28267           0 :         DATA_BLOB blob;
   28268           0 :         enum ndr_err_code err;
   28269             : 
   28270           0 :         if (ndr_table_dnsserver.num_calls < 2) {
   28271           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvQuery_ndr_pack");
   28272           0 :                 return NULL;
   28273             :         }
   28274           0 :         call = &ndr_table_dnsserver.calls[1];
   28275             : 
   28276           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
   28277           0 :         if (push == NULL) {
   28278           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
   28279           0 :                 return NULL;
   28280             :         }
   28281             : 
   28282           0 :         push->flags |= ndr_push_flags;
   28283             : 
   28284           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
   28285           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   28286           0 :                 TALLOC_FREE(push);
   28287           0 :                 PyErr_SetNdrError(err);
   28288           0 :                 return NULL;
   28289             :         }
   28290           0 :         blob = ndr_push_blob(push);
   28291           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
   28292           0 :         TALLOC_FREE(push);
   28293           0 :         return ret;
   28294             : }
   28295             : 
   28296           0 : static PyObject *py_DnssrvQuery_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   28297             : {
   28298           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
   28299           0 :         PyObject *bigendian_obj = NULL;
   28300           0 :         PyObject *ndr64_obj = NULL;
   28301           0 :         libndr_flags ndr_push_flags = 0;
   28302             : 
   28303           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
   28304             :                 discard_const_p(char *, kwnames),
   28305             :                 &bigendian_obj,
   28306             :                 &ndr64_obj)) {
   28307           0 :                 return NULL;
   28308             :         }
   28309             : 
   28310           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   28311           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
   28312             :         }
   28313           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   28314           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
   28315             :         }
   28316             : 
   28317           0 :         return py_DnssrvQuery_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
   28318             : }
   28319             : 
   28320           0 : static PyObject *py_DnssrvQuery_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   28321             : {
   28322           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
   28323           0 :         PyObject *bigendian_obj = NULL;
   28324           0 :         PyObject *ndr64_obj = NULL;
   28325           0 :         libndr_flags ndr_push_flags = 0;
   28326             : 
   28327           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
   28328             :                 discard_const_p(char *, kwnames),
   28329             :                 &bigendian_obj,
   28330             :                 &ndr64_obj)) {
   28331           0 :                 return NULL;
   28332             :         }
   28333             : 
   28334           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   28335           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
   28336             :         }
   28337           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   28338           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
   28339             :         }
   28340             : 
   28341           0 :         return py_DnssrvQuery_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
   28342             : }
   28343             : 
   28344           0 : static PyObject *py_DnssrvQuery_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
   28345             : {
   28346           0 :         const struct ndr_interface_call *call = NULL;
   28347           0 :         struct DnssrvQuery *object = pytalloc_get_ptr(py_obj);
   28348           0 :         struct ndr_pull *pull = NULL;
   28349           0 :         enum ndr_err_code err;
   28350             : 
   28351           0 :         if (ndr_table_dnsserver.num_calls < 2) {
   28352           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvQuery_ndr_unpack");
   28353           0 :                 return NULL;
   28354             :         }
   28355           0 :         call = &ndr_table_dnsserver.calls[1];
   28356             : 
   28357           0 :         pull = ndr_pull_init_blob(blob, object);
   28358           0 :         if (pull == NULL) {
   28359           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
   28360           0 :                 return NULL;
   28361             :         }
   28362             : 
   28363           0 :         pull->flags |= ndr_pull_flags;
   28364             : 
   28365           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
   28366           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   28367           0 :                 TALLOC_FREE(pull);
   28368           0 :                 PyErr_SetNdrError(err);
   28369           0 :                 return NULL;
   28370             :         }
   28371           0 :         if (!allow_remaining) {
   28372           0 :                 uint32_t highest_ofs;
   28373             : 
   28374           0 :                 if (pull->offset > pull->relative_highest_offset) {
   28375           0 :                         highest_ofs = pull->offset;
   28376             :                 } else {
   28377           0 :                         highest_ofs = pull->relative_highest_offset;
   28378             :                 }
   28379           0 :                 if (highest_ofs < pull->data_size) {
   28380           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
   28381             :                                 "not all bytes consumed ofs[%u] size[%u]",
   28382             :                                 highest_ofs, pull->data_size);
   28383           0 :                         TALLOC_FREE(pull);
   28384           0 :                         PyErr_SetNdrError(err);
   28385           0 :                         return NULL;
   28386             :                 }
   28387             :         }
   28388             : 
   28389           0 :         TALLOC_FREE(pull);
   28390           0 :         Py_RETURN_NONE;
   28391             : }
   28392             : 
   28393           0 : static PyObject *py_DnssrvQuery_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   28394             : {
   28395           0 :         DATA_BLOB blob;
   28396           0 :         Py_ssize_t blob_length = 0;
   28397           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
   28398           0 :         PyObject *bigendian_obj = NULL;
   28399           0 :         PyObject *ndr64_obj = NULL;
   28400           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
   28401           0 :         PyObject *allow_remaining_obj = NULL;
   28402           0 :         bool allow_remaining = false;
   28403             : 
   28404           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
   28405             :                 discard_const_p(char *, kwnames),
   28406             :                 &blob.data, &blob_length,
   28407             :                 &bigendian_obj,
   28408             :                 &ndr64_obj,
   28409             :                 &allow_remaining_obj)) {
   28410           0 :                 return NULL;
   28411             :         }
   28412           0 :         blob.length = blob_length;
   28413             : 
   28414           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   28415           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
   28416             :         }
   28417           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   28418           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
   28419             :         }
   28420             : 
   28421           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
   28422           0 :                 allow_remaining = true;
   28423             :         }
   28424             : 
   28425           0 :         return py_DnssrvQuery_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
   28426             : }
   28427             : 
   28428           0 : static PyObject *py_DnssrvQuery_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   28429             : {
   28430           0 :         DATA_BLOB blob;
   28431           0 :         Py_ssize_t blob_length = 0;
   28432           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
   28433           0 :         PyObject *bigendian_obj = NULL;
   28434           0 :         PyObject *ndr64_obj = NULL;
   28435           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
   28436           0 :         PyObject *allow_remaining_obj = NULL;
   28437           0 :         bool allow_remaining = false;
   28438             : 
   28439           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
   28440             :                 discard_const_p(char *, kwnames),
   28441             :                 &blob.data, &blob_length,
   28442             :                 &bigendian_obj,
   28443             :                 &ndr64_obj,
   28444             :                 &allow_remaining_obj)) {
   28445           0 :                 return NULL;
   28446             :         }
   28447           0 :         blob.length = blob_length;
   28448             : 
   28449           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   28450           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
   28451             :         }
   28452           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   28453           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
   28454             :         }
   28455             : 
   28456           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
   28457           0 :                 allow_remaining = true;
   28458             :         }
   28459             : 
   28460           0 :         return py_DnssrvQuery_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
   28461             : }
   28462             : 
   28463           0 : static PyObject *py_DnssrvQuery_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
   28464             : {
   28465           0 :         const struct ndr_interface_call *call = NULL;
   28466           0 :         struct DnssrvQuery *object = pytalloc_get_ptr(py_obj);
   28467           0 :         PyObject *ret;
   28468           0 :         char *retstr;
   28469             : 
   28470           0 :         if (ndr_table_dnsserver.num_calls < 2) {
   28471           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvQuery_ndr_print");
   28472           0 :                 return NULL;
   28473             :         }
   28474           0 :         call = &ndr_table_dnsserver.calls[1];
   28475             : 
   28476           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
   28477           0 :         ret = PyUnicode_FromString(retstr);
   28478           0 :         TALLOC_FREE(retstr);
   28479             : 
   28480           0 :         return ret;
   28481             : }
   28482             : 
   28483           0 : static PyObject *py_DnssrvQuery_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
   28484             : {
   28485           0 :         return py_DnssrvQuery_ndr_print(py_obj, "DnssrvQuery_in", NDR_IN);
   28486             : }
   28487             : 
   28488           0 : static PyObject *py_DnssrvQuery_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
   28489             : {
   28490           0 :         return py_DnssrvQuery_ndr_print(py_obj, "DnssrvQuery_out", NDR_OUT);
   28491             : }
   28492             : 
   28493             : static PyMethodDef py_DnssrvQuery_methods[] = {
   28494             :         { "opnum", (PyCFunction)py_DnssrvQuery_ndr_opnum, METH_NOARGS|METH_CLASS,
   28495             :                 "dnsserver.DnssrvQuery.opnum() -> 1 (0x01) " },
   28496             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvQuery_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
   28497             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
   28498             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvQuery_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
   28499             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
   28500             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvQuery_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
   28501             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
   28502             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvQuery_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
   28503             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
   28504             :         { "__ndr_print_in__", (PyCFunction)py_DnssrvQuery_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
   28505             :         { "__ndr_print_out__", (PyCFunction)py_DnssrvQuery_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
   28506             :         { NULL, NULL, 0, NULL }
   28507             : };
   28508             : 
   28509             : 
   28510             : static PyTypeObject DnssrvQuery_Type = {
   28511             :         PyVarObject_HEAD_INIT(NULL, 0)
   28512             :         .tp_name = "dnsserver.DnssrvQuery",
   28513             :         .tp_getset = py_DnssrvQuery_getsetters,
   28514             :         .tp_methods = py_DnssrvQuery_methods,
   28515             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   28516             :         .tp_new = py_DnssrvQuery_new,
   28517             : };
   28518             : 
   28519           0 : static bool pack_py_DnssrvQuery_args_in(PyObject *args, PyObject *kwargs, struct DnssrvQuery *r)
   28520             : {
   28521           0 :         PyObject *py_pwszServerName;
   28522           0 :         PyObject *py_pszZone;
   28523           0 :         PyObject *py_pszOperation;
   28524           0 :         const char *kwnames[] = {
   28525             :                 "pwszServerName", "pszZone", "pszOperation", NULL
   28526             :         };
   28527             : 
   28528           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DnssrvQuery", discard_const_p(char *, kwnames), &py_pwszServerName, &py_pszZone, &py_pszOperation)) {
   28529           0 :                 return false;
   28530             :         }
   28531             : 
   28532           0 :         if (py_pwszServerName == NULL) {
   28533           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pwszServerName");
   28534           0 :                 return false;
   28535             :         }
   28536           0 :         if (py_pwszServerName == Py_None) {
   28537           0 :                 r->in.pwszServerName = NULL;
   28538             :         } else {
   28539           0 :                 r->in.pwszServerName = NULL;
   28540             :                 {
   28541           0 :                         const char *test_str;
   28542           0 :                         const char *talloc_str;
   28543           0 :                         PyObject *unicode = NULL;
   28544           0 :                         if (PyUnicode_Check(py_pwszServerName)) {
   28545           0 :                                 unicode = PyUnicode_AsEncodedString(py_pwszServerName, "utf-8", "ignore");
   28546           0 :                                 if (unicode == NULL) {
   28547           0 :                                         return false;
   28548             :                                 }
   28549           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   28550           0 :                         } else if (PyBytes_Check(py_pwszServerName)) {
   28551           0 :                                 test_str = PyBytes_AS_STRING(py_pwszServerName);
   28552             :                         } else {
   28553           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pwszServerName)->tp_name);
   28554           0 :                                 return false;
   28555             :                         }
   28556           0 :                         talloc_str = talloc_strdup(r, test_str);
   28557           0 :                         if (unicode != NULL) {
   28558           0 :                                 Py_DECREF(unicode);
   28559             :                         }
   28560           0 :                         if (talloc_str == NULL) {
   28561           0 :                                 PyErr_NoMemory();
   28562           0 :                                 return false;
   28563             :                         }
   28564           0 :                         r->in.pwszServerName = talloc_str;
   28565             :                 }
   28566             :         }
   28567           0 :         if (py_pszZone == NULL) {
   28568           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszZone");
   28569           0 :                 return false;
   28570             :         }
   28571           0 :         if (py_pszZone == Py_None) {
   28572           0 :                 r->in.pszZone = NULL;
   28573             :         } else {
   28574           0 :                 r->in.pszZone = NULL;
   28575             :                 {
   28576           0 :                         const char *test_str;
   28577           0 :                         const char *talloc_str;
   28578           0 :                         PyObject *unicode = NULL;
   28579           0 :                         if (PyUnicode_Check(py_pszZone)) {
   28580           0 :                                 unicode = PyUnicode_AsEncodedString(py_pszZone, "utf-8", "ignore");
   28581           0 :                                 if (unicode == NULL) {
   28582           0 :                                         return false;
   28583             :                                 }
   28584           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   28585           0 :                         } else if (PyBytes_Check(py_pszZone)) {
   28586           0 :                                 test_str = PyBytes_AS_STRING(py_pszZone);
   28587             :                         } else {
   28588           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszZone)->tp_name);
   28589           0 :                                 return false;
   28590             :                         }
   28591           0 :                         talloc_str = talloc_strdup(r, test_str);
   28592           0 :                         if (unicode != NULL) {
   28593           0 :                                 Py_DECREF(unicode);
   28594             :                         }
   28595           0 :                         if (talloc_str == NULL) {
   28596           0 :                                 PyErr_NoMemory();
   28597           0 :                                 return false;
   28598             :                         }
   28599           0 :                         r->in.pszZone = talloc_str;
   28600             :                 }
   28601             :         }
   28602           0 :         if (py_pszOperation == NULL) {
   28603           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszOperation");
   28604           0 :                 return false;
   28605             :         }
   28606           0 :         if (py_pszOperation == Py_None) {
   28607           0 :                 r->in.pszOperation = NULL;
   28608             :         } else {
   28609           0 :                 r->in.pszOperation = NULL;
   28610             :                 {
   28611           0 :                         const char *test_str;
   28612           0 :                         const char *talloc_str;
   28613           0 :                         PyObject *unicode = NULL;
   28614           0 :                         if (PyUnicode_Check(py_pszOperation)) {
   28615           0 :                                 unicode = PyUnicode_AsEncodedString(py_pszOperation, "utf-8", "ignore");
   28616           0 :                                 if (unicode == NULL) {
   28617           0 :                                         return false;
   28618             :                                 }
   28619           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   28620           0 :                         } else if (PyBytes_Check(py_pszOperation)) {
   28621           0 :                                 test_str = PyBytes_AS_STRING(py_pszOperation);
   28622             :                         } else {
   28623           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszOperation)->tp_name);
   28624           0 :                                 return false;
   28625             :                         }
   28626           0 :                         talloc_str = talloc_strdup(r, test_str);
   28627           0 :                         if (unicode != NULL) {
   28628           0 :                                 Py_DECREF(unicode);
   28629             :                         }
   28630           0 :                         if (talloc_str == NULL) {
   28631           0 :                                 PyErr_NoMemory();
   28632           0 :                                 return false;
   28633             :                         }
   28634           0 :                         r->in.pszOperation = talloc_str;
   28635             :                 }
   28636             :         }
   28637           0 :         return true;
   28638             : }
   28639             : 
   28640           0 : static PyObject *unpack_py_DnssrvQuery_args_out(struct DnssrvQuery *r)
   28641             : {
   28642           0 :         PyObject *result;
   28643           0 :         PyObject *py_pdwTypeId;
   28644           0 :         PyObject *py_ppData;
   28645           0 :         result = PyTuple_New(2);
   28646           0 :         py_pdwTypeId = PyLong_FromUnsignedLongLong((uint32_t)(*r->out.pdwTypeId));
   28647           0 :         PyTuple_SetItem(result, 0, py_pdwTypeId);
   28648           0 :         py_ppData = pyrpc_import_union(&DNSSRV_RPC_UNION_Type, r->out.ppData, *r->out.pdwTypeId, r->out.ppData, "union DNSSRV_RPC_UNION");
   28649           0 :         if (py_ppData == NULL) {
   28650           0 :                 return NULL;
   28651             :         }
   28652           0 :         PyTuple_SetItem(result, 1, py_ppData);
   28653           0 :         if (!W_ERROR_IS_OK(r->out.result)) {
   28654           0 :                 PyErr_SetWERROR(r->out.result);
   28655           0 :                 return NULL;
   28656             :         }
   28657             : 
   28658           0 :         return result;
   28659             : }
   28660             : 
   28661             : 
   28662           0 : static PyObject *py_DnssrvComplexOperation_in_get_pwszServerName(PyObject *obj, void *closure)
   28663             : {
   28664           0 :         struct DnssrvComplexOperation *object = pytalloc_get_ptr(obj);
   28665           0 :         PyObject *py_pwszServerName;
   28666           0 :         if (object->in.pwszServerName == NULL) {
   28667           0 :                 Py_RETURN_NONE;
   28668             :         }
   28669           0 :         if (object->in.pwszServerName == NULL) {
   28670           0 :                 py_pwszServerName = Py_None;
   28671           0 :                 Py_INCREF(py_pwszServerName);
   28672             :         } else {
   28673           0 :                 if (object->in.pwszServerName == NULL) {
   28674           0 :                         py_pwszServerName = Py_None;
   28675           0 :                         Py_INCREF(py_pwszServerName);
   28676             :                 } else {
   28677           0 :                         py_pwszServerName = PyUnicode_Decode(object->in.pwszServerName, strlen(object->in.pwszServerName), "utf-8", "ignore");
   28678             :                 }
   28679             :         }
   28680           0 :         return py_pwszServerName;
   28681             : }
   28682             : 
   28683           0 : static int py_DnssrvComplexOperation_in_set_pwszServerName(PyObject *py_obj, PyObject *value, void *closure)
   28684             : {
   28685           0 :         struct DnssrvComplexOperation *object = pytalloc_get_ptr(py_obj);
   28686           0 :         if (value == NULL) {
   28687           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pwszServerName");
   28688           0 :                 return -1;
   28689             :         }
   28690           0 :         if (value == Py_None) {
   28691           0 :                 object->in.pwszServerName = NULL;
   28692             :         } else {
   28693           0 :                 object->in.pwszServerName = NULL;
   28694             :                 {
   28695           0 :                         const char *test_str;
   28696           0 :                         const char *talloc_str;
   28697           0 :                         PyObject *unicode = NULL;
   28698           0 :                         if (PyUnicode_Check(value)) {
   28699           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   28700           0 :                                 if (unicode == NULL) {
   28701           0 :                                         return -1;
   28702             :                                 }
   28703           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   28704           0 :                         } else if (PyBytes_Check(value)) {
   28705           0 :                                 test_str = PyBytes_AS_STRING(value);
   28706             :                         } else {
   28707           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   28708           0 :                                 return -1;
   28709             :                         }
   28710           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   28711           0 :                         if (unicode != NULL) {
   28712           0 :                                 Py_DECREF(unicode);
   28713             :                         }
   28714           0 :                         if (talloc_str == NULL) {
   28715           0 :                                 PyErr_NoMemory();
   28716           0 :                                 return -1;
   28717             :                         }
   28718           0 :                         object->in.pwszServerName = talloc_str;
   28719             :                 }
   28720             :         }
   28721           0 :         return 0;
   28722             : }
   28723             : 
   28724           0 : static PyObject *py_DnssrvComplexOperation_in_get_pszZone(PyObject *obj, void *closure)
   28725             : {
   28726           0 :         struct DnssrvComplexOperation *object = pytalloc_get_ptr(obj);
   28727           0 :         PyObject *py_pszZone;
   28728           0 :         if (object->in.pszZone == NULL) {
   28729           0 :                 Py_RETURN_NONE;
   28730             :         }
   28731           0 :         if (object->in.pszZone == NULL) {
   28732           0 :                 py_pszZone = Py_None;
   28733           0 :                 Py_INCREF(py_pszZone);
   28734             :         } else {
   28735           0 :                 if (object->in.pszZone == NULL) {
   28736           0 :                         py_pszZone = Py_None;
   28737           0 :                         Py_INCREF(py_pszZone);
   28738             :                 } else {
   28739           0 :                         py_pszZone = PyUnicode_Decode(object->in.pszZone, strlen(object->in.pszZone), "utf-8", "ignore");
   28740             :                 }
   28741             :         }
   28742           0 :         return py_pszZone;
   28743             : }
   28744             : 
   28745           0 : static int py_DnssrvComplexOperation_in_set_pszZone(PyObject *py_obj, PyObject *value, void *closure)
   28746             : {
   28747           0 :         struct DnssrvComplexOperation *object = pytalloc_get_ptr(py_obj);
   28748           0 :         if (value == NULL) {
   28749           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszZone");
   28750           0 :                 return -1;
   28751             :         }
   28752           0 :         if (value == Py_None) {
   28753           0 :                 object->in.pszZone = NULL;
   28754             :         } else {
   28755           0 :                 object->in.pszZone = NULL;
   28756             :                 {
   28757           0 :                         const char *test_str;
   28758           0 :                         const char *talloc_str;
   28759           0 :                         PyObject *unicode = NULL;
   28760           0 :                         if (PyUnicode_Check(value)) {
   28761           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   28762           0 :                                 if (unicode == NULL) {
   28763           0 :                                         return -1;
   28764             :                                 }
   28765           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   28766           0 :                         } else if (PyBytes_Check(value)) {
   28767           0 :                                 test_str = PyBytes_AS_STRING(value);
   28768             :                         } else {
   28769           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   28770           0 :                                 return -1;
   28771             :                         }
   28772           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   28773           0 :                         if (unicode != NULL) {
   28774           0 :                                 Py_DECREF(unicode);
   28775             :                         }
   28776           0 :                         if (talloc_str == NULL) {
   28777           0 :                                 PyErr_NoMemory();
   28778           0 :                                 return -1;
   28779             :                         }
   28780           0 :                         object->in.pszZone = talloc_str;
   28781             :                 }
   28782             :         }
   28783           0 :         return 0;
   28784             : }
   28785             : 
   28786           0 : static PyObject *py_DnssrvComplexOperation_in_get_pszOperation(PyObject *obj, void *closure)
   28787             : {
   28788           0 :         struct DnssrvComplexOperation *object = pytalloc_get_ptr(obj);
   28789           0 :         PyObject *py_pszOperation;
   28790           0 :         if (object->in.pszOperation == NULL) {
   28791           0 :                 Py_RETURN_NONE;
   28792             :         }
   28793           0 :         if (object->in.pszOperation == NULL) {
   28794           0 :                 py_pszOperation = Py_None;
   28795           0 :                 Py_INCREF(py_pszOperation);
   28796             :         } else {
   28797           0 :                 if (object->in.pszOperation == NULL) {
   28798           0 :                         py_pszOperation = Py_None;
   28799           0 :                         Py_INCREF(py_pszOperation);
   28800             :                 } else {
   28801           0 :                         py_pszOperation = PyUnicode_Decode(object->in.pszOperation, strlen(object->in.pszOperation), "utf-8", "ignore");
   28802             :                 }
   28803             :         }
   28804           0 :         return py_pszOperation;
   28805             : }
   28806             : 
   28807           0 : static int py_DnssrvComplexOperation_in_set_pszOperation(PyObject *py_obj, PyObject *value, void *closure)
   28808             : {
   28809           0 :         struct DnssrvComplexOperation *object = pytalloc_get_ptr(py_obj);
   28810           0 :         if (value == NULL) {
   28811           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszOperation");
   28812           0 :                 return -1;
   28813             :         }
   28814           0 :         if (value == Py_None) {
   28815           0 :                 object->in.pszOperation = NULL;
   28816             :         } else {
   28817           0 :                 object->in.pszOperation = NULL;
   28818             :                 {
   28819           0 :                         const char *test_str;
   28820           0 :                         const char *talloc_str;
   28821           0 :                         PyObject *unicode = NULL;
   28822           0 :                         if (PyUnicode_Check(value)) {
   28823           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   28824           0 :                                 if (unicode == NULL) {
   28825           0 :                                         return -1;
   28826             :                                 }
   28827           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   28828           0 :                         } else if (PyBytes_Check(value)) {
   28829           0 :                                 test_str = PyBytes_AS_STRING(value);
   28830             :                         } else {
   28831           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   28832           0 :                                 return -1;
   28833             :                         }
   28834           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   28835           0 :                         if (unicode != NULL) {
   28836           0 :                                 Py_DECREF(unicode);
   28837             :                         }
   28838           0 :                         if (talloc_str == NULL) {
   28839           0 :                                 PyErr_NoMemory();
   28840           0 :                                 return -1;
   28841             :                         }
   28842           0 :                         object->in.pszOperation = talloc_str;
   28843             :                 }
   28844             :         }
   28845           0 :         return 0;
   28846             : }
   28847             : 
   28848           0 : static PyObject *py_DnssrvComplexOperation_in_get_dwTypeIn(PyObject *obj, void *closure)
   28849             : {
   28850           0 :         struct DnssrvComplexOperation *object = pytalloc_get_ptr(obj);
   28851           0 :         PyObject *py_dwTypeIn;
   28852           0 :         py_dwTypeIn = PyLong_FromUnsignedLongLong((uint32_t)(object->in.dwTypeIn));
   28853           0 :         return py_dwTypeIn;
   28854             : }
   28855             : 
   28856           0 : static int py_DnssrvComplexOperation_in_set_dwTypeIn(PyObject *py_obj, PyObject *value, void *closure)
   28857             : {
   28858           0 :         struct DnssrvComplexOperation *object = pytalloc_get_ptr(py_obj);
   28859           0 :         if (value == NULL) {
   28860           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.dwTypeIn");
   28861           0 :                 return -1;
   28862             :         }
   28863             :         {
   28864           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.dwTypeIn));
   28865           0 :                 if (PyLong_Check(value)) {
   28866           0 :                         unsigned long long test_var;
   28867           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   28868           0 :                         if (PyErr_Occurred() != NULL) {
   28869           0 :                                 return -1;
   28870             :                         }
   28871           0 :                         if (test_var > uint_max) {
   28872           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   28873             :                                   PyLong_Type.tp_name, uint_max, test_var);
   28874           0 :                                 return -1;
   28875             :                         }
   28876           0 :                         object->in.dwTypeIn = test_var;
   28877             :                 } else {
   28878           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   28879             :                           PyLong_Type.tp_name);
   28880           0 :                         return -1;
   28881             :                 }
   28882             :         }
   28883           0 :         return 0;
   28884             : }
   28885             : 
   28886           0 : static PyObject *py_DnssrvComplexOperation_in_get_pDataIn(PyObject *obj, void *closure)
   28887             : {
   28888           0 :         struct DnssrvComplexOperation *object = pytalloc_get_ptr(obj);
   28889           0 :         PyObject *py_pDataIn;
   28890           0 :         py_pDataIn = pyrpc_import_union(&DNSSRV_RPC_UNION_Type, pytalloc_get_mem_ctx(obj), object->in.dwTypeIn, &object->in.pDataIn, "union DNSSRV_RPC_UNION");
   28891           0 :         if (py_pDataIn == NULL) {
   28892           0 :                 return NULL;
   28893             :         }
   28894           0 :         return py_pDataIn;
   28895             : }
   28896             : 
   28897           0 : static int py_DnssrvComplexOperation_in_set_pDataIn(PyObject *py_obj, PyObject *value, void *closure)
   28898             : {
   28899           0 :         struct DnssrvComplexOperation *object = pytalloc_get_ptr(py_obj);
   28900           0 :         if (value == NULL) {
   28901           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pDataIn");
   28902           0 :                 return -1;
   28903             :         }
   28904             :         {
   28905           0 :                 union DNSSRV_RPC_UNION *pDataIn_switch_0;
   28906           0 :                 pDataIn_switch_0 = (union DNSSRV_RPC_UNION *)pyrpc_export_union(&DNSSRV_RPC_UNION_Type, pytalloc_get_mem_ctx(py_obj), object->in.dwTypeIn, value, "union DNSSRV_RPC_UNION");
   28907           0 :                 if (pDataIn_switch_0 == NULL) {
   28908           0 :                         return -1;
   28909             :                 }
   28910           0 :                 object->in.pDataIn = *pDataIn_switch_0;
   28911             :         }
   28912           0 :         return 0;
   28913             : }
   28914             : 
   28915           0 : static PyObject *py_DnssrvComplexOperation_out_get_pdwTypeOut(PyObject *obj, void *closure)
   28916             : {
   28917           0 :         struct DnssrvComplexOperation *object = pytalloc_get_ptr(obj);
   28918           0 :         PyObject *py_pdwTypeOut;
   28919           0 :         if (object->out.pdwTypeOut == NULL) {
   28920           0 :                 Py_RETURN_NONE;
   28921             :         }
   28922           0 :         py_pdwTypeOut = PyLong_FromUnsignedLongLong((uint32_t)(*object->out.pdwTypeOut));
   28923           0 :         return py_pdwTypeOut;
   28924             : }
   28925             : 
   28926           0 : static int py_DnssrvComplexOperation_out_set_pdwTypeOut(PyObject *py_obj, PyObject *value, void *closure)
   28927             : {
   28928           0 :         struct DnssrvComplexOperation *object = pytalloc_get_ptr(py_obj);
   28929           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.pdwTypeOut));
   28930           0 :         if (value == NULL) {
   28931           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.pdwTypeOut");
   28932           0 :                 return -1;
   28933             :         }
   28934           0 :         object->out.pdwTypeOut = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.pdwTypeOut);
   28935           0 :         if (object->out.pdwTypeOut == NULL) {
   28936           0 :                 PyErr_NoMemory();
   28937           0 :                 return -1;
   28938             :         }
   28939             :         {
   28940           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->out.pdwTypeOut));
   28941           0 :                 if (PyLong_Check(value)) {
   28942           0 :                         unsigned long long test_var;
   28943           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   28944           0 :                         if (PyErr_Occurred() != NULL) {
   28945           0 :                                 return -1;
   28946             :                         }
   28947           0 :                         if (test_var > uint_max) {
   28948           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   28949             :                                   PyLong_Type.tp_name, uint_max, test_var);
   28950           0 :                                 return -1;
   28951             :                         }
   28952           0 :                         *object->out.pdwTypeOut = test_var;
   28953             :                 } else {
   28954           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   28955             :                           PyLong_Type.tp_name);
   28956           0 :                         return -1;
   28957             :                 }
   28958             :         }
   28959           0 :         return 0;
   28960             : }
   28961             : 
   28962           0 : static PyObject *py_DnssrvComplexOperation_out_get_ppDataOut(PyObject *obj, void *closure)
   28963             : {
   28964           0 :         struct DnssrvComplexOperation *object = pytalloc_get_ptr(obj);
   28965           0 :         PyObject *py_ppDataOut;
   28966           0 :         if (object->out.ppDataOut == NULL) {
   28967           0 :                 Py_RETURN_NONE;
   28968             :         }
   28969           0 :         py_ppDataOut = pyrpc_import_union(&DNSSRV_RPC_UNION_Type, object->out.ppDataOut, *object->out.pdwTypeOut, object->out.ppDataOut, "union DNSSRV_RPC_UNION");
   28970           0 :         if (py_ppDataOut == NULL) {
   28971           0 :                 return NULL;
   28972             :         }
   28973           0 :         return py_ppDataOut;
   28974             : }
   28975             : 
   28976           0 : static int py_DnssrvComplexOperation_out_set_ppDataOut(PyObject *py_obj, PyObject *value, void *closure)
   28977             : {
   28978           0 :         struct DnssrvComplexOperation *object = pytalloc_get_ptr(py_obj);
   28979           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.ppDataOut));
   28980           0 :         if (value == NULL) {
   28981           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.ppDataOut");
   28982           0 :                 return -1;
   28983             :         }
   28984           0 :         object->out.ppDataOut = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.ppDataOut);
   28985           0 :         if (object->out.ppDataOut == NULL) {
   28986           0 :                 PyErr_NoMemory();
   28987           0 :                 return -1;
   28988             :         }
   28989             :         {
   28990           0 :                 union DNSSRV_RPC_UNION *ppDataOut_switch_1;
   28991           0 :                 ppDataOut_switch_1 = (union DNSSRV_RPC_UNION *)pyrpc_export_union(&DNSSRV_RPC_UNION_Type, pytalloc_get_mem_ctx(py_obj), *object->out.pdwTypeOut, value, "union DNSSRV_RPC_UNION");
   28992           0 :                 if (ppDataOut_switch_1 == NULL) {
   28993           0 :                         return -1;
   28994             :                 }
   28995           0 :                 object->out.ppDataOut = ppDataOut_switch_1;
   28996             :         }
   28997           0 :         return 0;
   28998             : }
   28999             : 
   29000           0 : static PyObject *py_DnssrvComplexOperation_get_result(PyObject *obj, void *closure)
   29001             : {
   29002           0 :         struct DnssrvComplexOperation *object = pytalloc_get_ptr(obj);
   29003           0 :         PyObject *py_result;
   29004           0 :         py_result = PyErr_FromWERROR(object->out.result);
   29005           0 :         return py_result;
   29006             : }
   29007             : 
   29008           0 : static int py_DnssrvComplexOperation_set_result(PyObject *py_obj, PyObject *value, void *closure)
   29009             : {
   29010           0 :         struct DnssrvComplexOperation *object = pytalloc_get_ptr(py_obj);
   29011           0 :         if (value == NULL) {
   29012           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.result");
   29013           0 :                 return -1;
   29014             :         }
   29015           0 :         object->out.result = W_ERROR(PyLong_AsLong(value));
   29016           0 :         return 0;
   29017             : }
   29018             : 
   29019             : static PyGetSetDef py_DnssrvComplexOperation_getsetters[] = {
   29020             :         {
   29021             :                 .name = discard_const_p(char, "in_pwszServerName"),
   29022             :                 .get = py_DnssrvComplexOperation_in_get_pwszServerName,
   29023             :                 .set = py_DnssrvComplexOperation_in_set_pwszServerName,
   29024             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
   29025             :         },
   29026             :         {
   29027             :                 .name = discard_const_p(char, "in_pszZone"),
   29028             :                 .get = py_DnssrvComplexOperation_in_get_pszZone,
   29029             :                 .set = py_DnssrvComplexOperation_in_set_pszZone,
   29030             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   29031             :         },
   29032             :         {
   29033             :                 .name = discard_const_p(char, "in_pszOperation"),
   29034             :                 .get = py_DnssrvComplexOperation_in_get_pszOperation,
   29035             :                 .set = py_DnssrvComplexOperation_in_set_pszOperation,
   29036             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   29037             :         },
   29038             :         {
   29039             :                 .name = discard_const_p(char, "in_dwTypeIn"),
   29040             :                 .get = py_DnssrvComplexOperation_in_get_dwTypeIn,
   29041             :                 .set = py_DnssrvComplexOperation_in_set_dwTypeIn,
   29042             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_TYPEID")
   29043             :         },
   29044             :         {
   29045             :                 .name = discard_const_p(char, "in_pDataIn"),
   29046             :                 .get = py_DnssrvComplexOperation_in_get_pDataIn,
   29047             :                 .set = py_DnssrvComplexOperation_in_set_pDataIn,
   29048             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNSSRV_RPC_UNION")
   29049             :         },
   29050             :         {
   29051             :                 .name = discard_const_p(char, "out_pdwTypeOut"),
   29052             :                 .get = py_DnssrvComplexOperation_out_get_pdwTypeOut,
   29053             :                 .set = py_DnssrvComplexOperation_out_set_pdwTypeOut,
   29054             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_TYPEID")
   29055             :         },
   29056             :         {
   29057             :                 .name = discard_const_p(char, "out_ppDataOut"),
   29058             :                 .get = py_DnssrvComplexOperation_out_get_ppDataOut,
   29059             :                 .set = py_DnssrvComplexOperation_out_set_ppDataOut,
   29060             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNSSRV_RPC_UNION")
   29061             :         },
   29062             :         {
   29063             :                 .name = discard_const_p(char, "result"),
   29064             :                 .get = py_DnssrvComplexOperation_get_result,
   29065             :                 .set = py_DnssrvComplexOperation_set_result,
   29066             :                 .doc = discard_const_p(char, "PIDL-generated element of type WERROR")
   29067             :         },
   29068             :         { .name = NULL }
   29069             : };
   29070             : 
   29071           0 : static PyObject *py_DnssrvComplexOperation_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   29072             : {
   29073           0 :         PyObject *self = pytalloc_new(struct DnssrvComplexOperation, type);
   29074           0 :         struct DnssrvComplexOperation *_self = (struct DnssrvComplexOperation *)pytalloc_get_ptr(self);
   29075           0 :         TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
   29076           0 :         _self->out.pdwTypeOut = talloc_zero(mem_ctx, enum DNS_RPC_TYPEID);
   29077           0 :         _self->out.ppDataOut = talloc_zero(mem_ctx, union DNSSRV_RPC_UNION);
   29078           0 :         return self;
   29079             : }
   29080             : 
   29081           0 : static PyObject *py_DnssrvComplexOperation_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
   29082             : {
   29083             : 
   29084             : 
   29085           0 :         return PyLong_FromLong(2);
   29086             : }
   29087             : 
   29088           0 : static PyObject *py_DnssrvComplexOperation_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
   29089             : {
   29090           0 :         const struct ndr_interface_call *call = NULL;
   29091           0 :         struct DnssrvComplexOperation *object = pytalloc_get_ptr(py_obj);
   29092           0 :         PyObject *ret = NULL;
   29093           0 :         struct ndr_push *push = NULL;
   29094           0 :         DATA_BLOB blob;
   29095           0 :         enum ndr_err_code err;
   29096             : 
   29097           0 :         if (ndr_table_dnsserver.num_calls < 3) {
   29098           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvComplexOperation_ndr_pack");
   29099           0 :                 return NULL;
   29100             :         }
   29101           0 :         call = &ndr_table_dnsserver.calls[2];
   29102             : 
   29103           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
   29104           0 :         if (push == NULL) {
   29105           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
   29106           0 :                 return NULL;
   29107             :         }
   29108             : 
   29109           0 :         push->flags |= ndr_push_flags;
   29110             : 
   29111           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
   29112           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   29113           0 :                 TALLOC_FREE(push);
   29114           0 :                 PyErr_SetNdrError(err);
   29115           0 :                 return NULL;
   29116             :         }
   29117           0 :         blob = ndr_push_blob(push);
   29118           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
   29119           0 :         TALLOC_FREE(push);
   29120           0 :         return ret;
   29121             : }
   29122             : 
   29123           0 : static PyObject *py_DnssrvComplexOperation_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   29124             : {
   29125           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
   29126           0 :         PyObject *bigendian_obj = NULL;
   29127           0 :         PyObject *ndr64_obj = NULL;
   29128           0 :         libndr_flags ndr_push_flags = 0;
   29129             : 
   29130           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
   29131             :                 discard_const_p(char *, kwnames),
   29132             :                 &bigendian_obj,
   29133             :                 &ndr64_obj)) {
   29134           0 :                 return NULL;
   29135             :         }
   29136             : 
   29137           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   29138           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
   29139             :         }
   29140           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   29141           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
   29142             :         }
   29143             : 
   29144           0 :         return py_DnssrvComplexOperation_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
   29145             : }
   29146             : 
   29147           0 : static PyObject *py_DnssrvComplexOperation_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   29148             : {
   29149           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
   29150           0 :         PyObject *bigendian_obj = NULL;
   29151           0 :         PyObject *ndr64_obj = NULL;
   29152           0 :         libndr_flags ndr_push_flags = 0;
   29153             : 
   29154           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
   29155             :                 discard_const_p(char *, kwnames),
   29156             :                 &bigendian_obj,
   29157             :                 &ndr64_obj)) {
   29158           0 :                 return NULL;
   29159             :         }
   29160             : 
   29161           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   29162           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
   29163             :         }
   29164           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   29165           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
   29166             :         }
   29167             : 
   29168           0 :         return py_DnssrvComplexOperation_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
   29169             : }
   29170             : 
   29171           0 : static PyObject *py_DnssrvComplexOperation_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
   29172             : {
   29173           0 :         const struct ndr_interface_call *call = NULL;
   29174           0 :         struct DnssrvComplexOperation *object = pytalloc_get_ptr(py_obj);
   29175           0 :         struct ndr_pull *pull = NULL;
   29176           0 :         enum ndr_err_code err;
   29177             : 
   29178           0 :         if (ndr_table_dnsserver.num_calls < 3) {
   29179           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvComplexOperation_ndr_unpack");
   29180           0 :                 return NULL;
   29181             :         }
   29182           0 :         call = &ndr_table_dnsserver.calls[2];
   29183             : 
   29184           0 :         pull = ndr_pull_init_blob(blob, object);
   29185           0 :         if (pull == NULL) {
   29186           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
   29187           0 :                 return NULL;
   29188             :         }
   29189             : 
   29190           0 :         pull->flags |= ndr_pull_flags;
   29191             : 
   29192           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
   29193           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   29194           0 :                 TALLOC_FREE(pull);
   29195           0 :                 PyErr_SetNdrError(err);
   29196           0 :                 return NULL;
   29197             :         }
   29198           0 :         if (!allow_remaining) {
   29199           0 :                 uint32_t highest_ofs;
   29200             : 
   29201           0 :                 if (pull->offset > pull->relative_highest_offset) {
   29202           0 :                         highest_ofs = pull->offset;
   29203             :                 } else {
   29204           0 :                         highest_ofs = pull->relative_highest_offset;
   29205             :                 }
   29206           0 :                 if (highest_ofs < pull->data_size) {
   29207           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
   29208             :                                 "not all bytes consumed ofs[%u] size[%u]",
   29209             :                                 highest_ofs, pull->data_size);
   29210           0 :                         TALLOC_FREE(pull);
   29211           0 :                         PyErr_SetNdrError(err);
   29212           0 :                         return NULL;
   29213             :                 }
   29214             :         }
   29215             : 
   29216           0 :         TALLOC_FREE(pull);
   29217           0 :         Py_RETURN_NONE;
   29218             : }
   29219             : 
   29220           0 : static PyObject *py_DnssrvComplexOperation_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   29221             : {
   29222           0 :         DATA_BLOB blob;
   29223           0 :         Py_ssize_t blob_length = 0;
   29224           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
   29225           0 :         PyObject *bigendian_obj = NULL;
   29226           0 :         PyObject *ndr64_obj = NULL;
   29227           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
   29228           0 :         PyObject *allow_remaining_obj = NULL;
   29229           0 :         bool allow_remaining = false;
   29230             : 
   29231           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
   29232             :                 discard_const_p(char *, kwnames),
   29233             :                 &blob.data, &blob_length,
   29234             :                 &bigendian_obj,
   29235             :                 &ndr64_obj,
   29236             :                 &allow_remaining_obj)) {
   29237           0 :                 return NULL;
   29238             :         }
   29239           0 :         blob.length = blob_length;
   29240             : 
   29241           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   29242           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
   29243             :         }
   29244           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   29245           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
   29246             :         }
   29247             : 
   29248           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
   29249           0 :                 allow_remaining = true;
   29250             :         }
   29251             : 
   29252           0 :         return py_DnssrvComplexOperation_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
   29253             : }
   29254             : 
   29255           0 : static PyObject *py_DnssrvComplexOperation_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   29256             : {
   29257           0 :         DATA_BLOB blob;
   29258           0 :         Py_ssize_t blob_length = 0;
   29259           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
   29260           0 :         PyObject *bigendian_obj = NULL;
   29261           0 :         PyObject *ndr64_obj = NULL;
   29262           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
   29263           0 :         PyObject *allow_remaining_obj = NULL;
   29264           0 :         bool allow_remaining = false;
   29265             : 
   29266           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
   29267             :                 discard_const_p(char *, kwnames),
   29268             :                 &blob.data, &blob_length,
   29269             :                 &bigendian_obj,
   29270             :                 &ndr64_obj,
   29271             :                 &allow_remaining_obj)) {
   29272           0 :                 return NULL;
   29273             :         }
   29274           0 :         blob.length = blob_length;
   29275             : 
   29276           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   29277           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
   29278             :         }
   29279           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   29280           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
   29281             :         }
   29282             : 
   29283           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
   29284           0 :                 allow_remaining = true;
   29285             :         }
   29286             : 
   29287           0 :         return py_DnssrvComplexOperation_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
   29288             : }
   29289             : 
   29290           0 : static PyObject *py_DnssrvComplexOperation_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
   29291             : {
   29292           0 :         const struct ndr_interface_call *call = NULL;
   29293           0 :         struct DnssrvComplexOperation *object = pytalloc_get_ptr(py_obj);
   29294           0 :         PyObject *ret;
   29295           0 :         char *retstr;
   29296             : 
   29297           0 :         if (ndr_table_dnsserver.num_calls < 3) {
   29298           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvComplexOperation_ndr_print");
   29299           0 :                 return NULL;
   29300             :         }
   29301           0 :         call = &ndr_table_dnsserver.calls[2];
   29302             : 
   29303           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
   29304           0 :         ret = PyUnicode_FromString(retstr);
   29305           0 :         TALLOC_FREE(retstr);
   29306             : 
   29307           0 :         return ret;
   29308             : }
   29309             : 
   29310           0 : static PyObject *py_DnssrvComplexOperation_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
   29311             : {
   29312           0 :         return py_DnssrvComplexOperation_ndr_print(py_obj, "DnssrvComplexOperation_in", NDR_IN);
   29313             : }
   29314             : 
   29315           0 : static PyObject *py_DnssrvComplexOperation_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
   29316             : {
   29317           0 :         return py_DnssrvComplexOperation_ndr_print(py_obj, "DnssrvComplexOperation_out", NDR_OUT);
   29318             : }
   29319             : 
   29320             : static PyMethodDef py_DnssrvComplexOperation_methods[] = {
   29321             :         { "opnum", (PyCFunction)py_DnssrvComplexOperation_ndr_opnum, METH_NOARGS|METH_CLASS,
   29322             :                 "dnsserver.DnssrvComplexOperation.opnum() -> 2 (0x02) " },
   29323             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvComplexOperation_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
   29324             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
   29325             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvComplexOperation_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
   29326             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
   29327             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvComplexOperation_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
   29328             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
   29329             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvComplexOperation_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
   29330             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
   29331             :         { "__ndr_print_in__", (PyCFunction)py_DnssrvComplexOperation_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
   29332             :         { "__ndr_print_out__", (PyCFunction)py_DnssrvComplexOperation_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
   29333             :         { NULL, NULL, 0, NULL }
   29334             : };
   29335             : 
   29336             : 
   29337             : static PyTypeObject DnssrvComplexOperation_Type = {
   29338             :         PyVarObject_HEAD_INIT(NULL, 0)
   29339             :         .tp_name = "dnsserver.DnssrvComplexOperation",
   29340             :         .tp_getset = py_DnssrvComplexOperation_getsetters,
   29341             :         .tp_methods = py_DnssrvComplexOperation_methods,
   29342             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   29343             :         .tp_new = py_DnssrvComplexOperation_new,
   29344             : };
   29345             : 
   29346           0 : static bool pack_py_DnssrvComplexOperation_args_in(PyObject *args, PyObject *kwargs, struct DnssrvComplexOperation *r)
   29347             : {
   29348           0 :         PyObject *py_pwszServerName;
   29349           0 :         PyObject *py_pszZone;
   29350           0 :         PyObject *py_pszOperation;
   29351           0 :         PyObject *py_dwTypeIn;
   29352           0 :         PyObject *py_pDataIn;
   29353           0 :         const char *kwnames[] = {
   29354             :                 "pwszServerName", "pszZone", "pszOperation", "dwTypeIn", "pDataIn", NULL
   29355             :         };
   29356             : 
   29357           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:DnssrvComplexOperation", discard_const_p(char *, kwnames), &py_pwszServerName, &py_pszZone, &py_pszOperation, &py_dwTypeIn, &py_pDataIn)) {
   29358           0 :                 return false;
   29359             :         }
   29360             : 
   29361           0 :         if (py_pwszServerName == NULL) {
   29362           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pwszServerName");
   29363           0 :                 return false;
   29364             :         }
   29365           0 :         if (py_pwszServerName == Py_None) {
   29366           0 :                 r->in.pwszServerName = NULL;
   29367             :         } else {
   29368           0 :                 r->in.pwszServerName = NULL;
   29369             :                 {
   29370           0 :                         const char *test_str;
   29371           0 :                         const char *talloc_str;
   29372           0 :                         PyObject *unicode = NULL;
   29373           0 :                         if (PyUnicode_Check(py_pwszServerName)) {
   29374           0 :                                 unicode = PyUnicode_AsEncodedString(py_pwszServerName, "utf-8", "ignore");
   29375           0 :                                 if (unicode == NULL) {
   29376           0 :                                         return false;
   29377             :                                 }
   29378           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   29379           0 :                         } else if (PyBytes_Check(py_pwszServerName)) {
   29380           0 :                                 test_str = PyBytes_AS_STRING(py_pwszServerName);
   29381             :                         } else {
   29382           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pwszServerName)->tp_name);
   29383           0 :                                 return false;
   29384             :                         }
   29385           0 :                         talloc_str = talloc_strdup(r, test_str);
   29386           0 :                         if (unicode != NULL) {
   29387           0 :                                 Py_DECREF(unicode);
   29388             :                         }
   29389           0 :                         if (talloc_str == NULL) {
   29390           0 :                                 PyErr_NoMemory();
   29391           0 :                                 return false;
   29392             :                         }
   29393           0 :                         r->in.pwszServerName = talloc_str;
   29394             :                 }
   29395             :         }
   29396           0 :         if (py_pszZone == NULL) {
   29397           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszZone");
   29398           0 :                 return false;
   29399             :         }
   29400           0 :         if (py_pszZone == Py_None) {
   29401           0 :                 r->in.pszZone = NULL;
   29402             :         } else {
   29403           0 :                 r->in.pszZone = NULL;
   29404             :                 {
   29405           0 :                         const char *test_str;
   29406           0 :                         const char *talloc_str;
   29407           0 :                         PyObject *unicode = NULL;
   29408           0 :                         if (PyUnicode_Check(py_pszZone)) {
   29409           0 :                                 unicode = PyUnicode_AsEncodedString(py_pszZone, "utf-8", "ignore");
   29410           0 :                                 if (unicode == NULL) {
   29411           0 :                                         return false;
   29412             :                                 }
   29413           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   29414           0 :                         } else if (PyBytes_Check(py_pszZone)) {
   29415           0 :                                 test_str = PyBytes_AS_STRING(py_pszZone);
   29416             :                         } else {
   29417           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszZone)->tp_name);
   29418           0 :                                 return false;
   29419             :                         }
   29420           0 :                         talloc_str = talloc_strdup(r, test_str);
   29421           0 :                         if (unicode != NULL) {
   29422           0 :                                 Py_DECREF(unicode);
   29423             :                         }
   29424           0 :                         if (talloc_str == NULL) {
   29425           0 :                                 PyErr_NoMemory();
   29426           0 :                                 return false;
   29427             :                         }
   29428           0 :                         r->in.pszZone = talloc_str;
   29429             :                 }
   29430             :         }
   29431           0 :         if (py_pszOperation == NULL) {
   29432           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszOperation");
   29433           0 :                 return false;
   29434             :         }
   29435           0 :         if (py_pszOperation == Py_None) {
   29436           0 :                 r->in.pszOperation = NULL;
   29437             :         } else {
   29438           0 :                 r->in.pszOperation = NULL;
   29439             :                 {
   29440           0 :                         const char *test_str;
   29441           0 :                         const char *talloc_str;
   29442           0 :                         PyObject *unicode = NULL;
   29443           0 :                         if (PyUnicode_Check(py_pszOperation)) {
   29444           0 :                                 unicode = PyUnicode_AsEncodedString(py_pszOperation, "utf-8", "ignore");
   29445           0 :                                 if (unicode == NULL) {
   29446           0 :                                         return false;
   29447             :                                 }
   29448           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   29449           0 :                         } else if (PyBytes_Check(py_pszOperation)) {
   29450           0 :                                 test_str = PyBytes_AS_STRING(py_pszOperation);
   29451             :                         } else {
   29452           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszOperation)->tp_name);
   29453           0 :                                 return false;
   29454             :                         }
   29455           0 :                         talloc_str = talloc_strdup(r, test_str);
   29456           0 :                         if (unicode != NULL) {
   29457           0 :                                 Py_DECREF(unicode);
   29458             :                         }
   29459           0 :                         if (talloc_str == NULL) {
   29460           0 :                                 PyErr_NoMemory();
   29461           0 :                                 return false;
   29462             :                         }
   29463           0 :                         r->in.pszOperation = talloc_str;
   29464             :                 }
   29465             :         }
   29466           0 :         if (py_dwTypeIn == NULL) {
   29467           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.dwTypeIn");
   29468           0 :                 return false;
   29469             :         }
   29470             :         {
   29471           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.dwTypeIn));
   29472           0 :                 if (PyLong_Check(py_dwTypeIn)) {
   29473           0 :                         unsigned long long test_var;
   29474           0 :                         test_var = PyLong_AsUnsignedLongLong(py_dwTypeIn);
   29475           0 :                         if (PyErr_Occurred() != NULL) {
   29476           0 :                                 return false;
   29477             :                         }
   29478           0 :                         if (test_var > uint_max) {
   29479           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   29480             :                                   PyLong_Type.tp_name, uint_max, test_var);
   29481           0 :                                 return false;
   29482             :                         }
   29483           0 :                         r->in.dwTypeIn = test_var;
   29484             :                 } else {
   29485           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   29486             :                           PyLong_Type.tp_name);
   29487           0 :                         return false;
   29488             :                 }
   29489             :         }
   29490           0 :         if (py_pDataIn == NULL) {
   29491           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pDataIn");
   29492           0 :                 return false;
   29493             :         }
   29494             :         {
   29495           0 :                 union DNSSRV_RPC_UNION *pDataIn_switch_0;
   29496           0 :                 pDataIn_switch_0 = (union DNSSRV_RPC_UNION *)pyrpc_export_union(&DNSSRV_RPC_UNION_Type, r, r->in.dwTypeIn, py_pDataIn, "union DNSSRV_RPC_UNION");
   29497           0 :                 if (pDataIn_switch_0 == NULL) {
   29498           0 :                         return false;
   29499             :                 }
   29500           0 :                 r->in.pDataIn = *pDataIn_switch_0;
   29501             :         }
   29502           0 :         return true;
   29503             : }
   29504             : 
   29505           0 : static PyObject *unpack_py_DnssrvComplexOperation_args_out(struct DnssrvComplexOperation *r)
   29506             : {
   29507           0 :         PyObject *result;
   29508           0 :         PyObject *py_pdwTypeOut;
   29509           0 :         PyObject *py_ppDataOut;
   29510           0 :         result = PyTuple_New(2);
   29511           0 :         py_pdwTypeOut = PyLong_FromUnsignedLongLong((uint32_t)(*r->out.pdwTypeOut));
   29512           0 :         PyTuple_SetItem(result, 0, py_pdwTypeOut);
   29513           0 :         py_ppDataOut = pyrpc_import_union(&DNSSRV_RPC_UNION_Type, r->out.ppDataOut, *r->out.pdwTypeOut, r->out.ppDataOut, "union DNSSRV_RPC_UNION");
   29514           0 :         if (py_ppDataOut == NULL) {
   29515           0 :                 return NULL;
   29516             :         }
   29517           0 :         PyTuple_SetItem(result, 1, py_ppDataOut);
   29518           0 :         if (!W_ERROR_IS_OK(r->out.result)) {
   29519           0 :                 PyErr_SetWERROR(r->out.result);
   29520           0 :                 return NULL;
   29521             :         }
   29522             : 
   29523           0 :         return result;
   29524             : }
   29525             : 
   29526             : 
   29527           0 : static PyObject *py_DnssrvEnumRecords_in_get_pwszServerName(PyObject *obj, void *closure)
   29528             : {
   29529           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(obj);
   29530           0 :         PyObject *py_pwszServerName;
   29531           0 :         if (object->in.pwszServerName == NULL) {
   29532           0 :                 Py_RETURN_NONE;
   29533             :         }
   29534           0 :         if (object->in.pwszServerName == NULL) {
   29535           0 :                 py_pwszServerName = Py_None;
   29536           0 :                 Py_INCREF(py_pwszServerName);
   29537             :         } else {
   29538           0 :                 if (object->in.pwszServerName == NULL) {
   29539           0 :                         py_pwszServerName = Py_None;
   29540           0 :                         Py_INCREF(py_pwszServerName);
   29541             :                 } else {
   29542           0 :                         py_pwszServerName = PyUnicode_Decode(object->in.pwszServerName, strlen(object->in.pwszServerName), "utf-8", "ignore");
   29543             :                 }
   29544             :         }
   29545           0 :         return py_pwszServerName;
   29546             : }
   29547             : 
   29548           0 : static int py_DnssrvEnumRecords_in_set_pwszServerName(PyObject *py_obj, PyObject *value, void *closure)
   29549             : {
   29550           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(py_obj);
   29551           0 :         if (value == NULL) {
   29552           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pwszServerName");
   29553           0 :                 return -1;
   29554             :         }
   29555           0 :         if (value == Py_None) {
   29556           0 :                 object->in.pwszServerName = NULL;
   29557             :         } else {
   29558           0 :                 object->in.pwszServerName = NULL;
   29559             :                 {
   29560           0 :                         const char *test_str;
   29561           0 :                         const char *talloc_str;
   29562           0 :                         PyObject *unicode = NULL;
   29563           0 :                         if (PyUnicode_Check(value)) {
   29564           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   29565           0 :                                 if (unicode == NULL) {
   29566           0 :                                         return -1;
   29567             :                                 }
   29568           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   29569           0 :                         } else if (PyBytes_Check(value)) {
   29570           0 :                                 test_str = PyBytes_AS_STRING(value);
   29571             :                         } else {
   29572           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   29573           0 :                                 return -1;
   29574             :                         }
   29575           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   29576           0 :                         if (unicode != NULL) {
   29577           0 :                                 Py_DECREF(unicode);
   29578             :                         }
   29579           0 :                         if (talloc_str == NULL) {
   29580           0 :                                 PyErr_NoMemory();
   29581           0 :                                 return -1;
   29582             :                         }
   29583           0 :                         object->in.pwszServerName = talloc_str;
   29584             :                 }
   29585             :         }
   29586           0 :         return 0;
   29587             : }
   29588             : 
   29589           0 : static PyObject *py_DnssrvEnumRecords_in_get_pszZone(PyObject *obj, void *closure)
   29590             : {
   29591           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(obj);
   29592           0 :         PyObject *py_pszZone;
   29593           0 :         if (object->in.pszZone == NULL) {
   29594           0 :                 Py_RETURN_NONE;
   29595             :         }
   29596           0 :         if (object->in.pszZone == NULL) {
   29597           0 :                 py_pszZone = Py_None;
   29598           0 :                 Py_INCREF(py_pszZone);
   29599             :         } else {
   29600           0 :                 if (object->in.pszZone == NULL) {
   29601           0 :                         py_pszZone = Py_None;
   29602           0 :                         Py_INCREF(py_pszZone);
   29603             :                 } else {
   29604           0 :                         py_pszZone = PyUnicode_Decode(object->in.pszZone, strlen(object->in.pszZone), "utf-8", "ignore");
   29605             :                 }
   29606             :         }
   29607           0 :         return py_pszZone;
   29608             : }
   29609             : 
   29610           0 : static int py_DnssrvEnumRecords_in_set_pszZone(PyObject *py_obj, PyObject *value, void *closure)
   29611             : {
   29612           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(py_obj);
   29613           0 :         if (value == NULL) {
   29614           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszZone");
   29615           0 :                 return -1;
   29616             :         }
   29617           0 :         if (value == Py_None) {
   29618           0 :                 object->in.pszZone = NULL;
   29619             :         } else {
   29620           0 :                 object->in.pszZone = NULL;
   29621             :                 {
   29622           0 :                         const char *test_str;
   29623           0 :                         const char *talloc_str;
   29624           0 :                         PyObject *unicode = NULL;
   29625           0 :                         if (PyUnicode_Check(value)) {
   29626           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   29627           0 :                                 if (unicode == NULL) {
   29628           0 :                                         return -1;
   29629             :                                 }
   29630           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   29631           0 :                         } else if (PyBytes_Check(value)) {
   29632           0 :                                 test_str = PyBytes_AS_STRING(value);
   29633             :                         } else {
   29634           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   29635           0 :                                 return -1;
   29636             :                         }
   29637           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   29638           0 :                         if (unicode != NULL) {
   29639           0 :                                 Py_DECREF(unicode);
   29640             :                         }
   29641           0 :                         if (talloc_str == NULL) {
   29642           0 :                                 PyErr_NoMemory();
   29643           0 :                                 return -1;
   29644             :                         }
   29645           0 :                         object->in.pszZone = talloc_str;
   29646             :                 }
   29647             :         }
   29648           0 :         return 0;
   29649             : }
   29650             : 
   29651           0 : static PyObject *py_DnssrvEnumRecords_in_get_pszNodeName(PyObject *obj, void *closure)
   29652             : {
   29653           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(obj);
   29654           0 :         PyObject *py_pszNodeName;
   29655           0 :         if (object->in.pszNodeName == NULL) {
   29656           0 :                 Py_RETURN_NONE;
   29657             :         }
   29658           0 :         if (object->in.pszNodeName == NULL) {
   29659           0 :                 py_pszNodeName = Py_None;
   29660           0 :                 Py_INCREF(py_pszNodeName);
   29661             :         } else {
   29662           0 :                 if (object->in.pszNodeName == NULL) {
   29663           0 :                         py_pszNodeName = Py_None;
   29664           0 :                         Py_INCREF(py_pszNodeName);
   29665             :                 } else {
   29666           0 :                         py_pszNodeName = PyUnicode_Decode(object->in.pszNodeName, strlen(object->in.pszNodeName), "utf-8", "ignore");
   29667             :                 }
   29668             :         }
   29669           0 :         return py_pszNodeName;
   29670             : }
   29671             : 
   29672           0 : static int py_DnssrvEnumRecords_in_set_pszNodeName(PyObject *py_obj, PyObject *value, void *closure)
   29673             : {
   29674           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(py_obj);
   29675           0 :         if (value == NULL) {
   29676           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszNodeName");
   29677           0 :                 return -1;
   29678             :         }
   29679           0 :         if (value == Py_None) {
   29680           0 :                 object->in.pszNodeName = NULL;
   29681             :         } else {
   29682           0 :                 object->in.pszNodeName = NULL;
   29683             :                 {
   29684           0 :                         const char *test_str;
   29685           0 :                         const char *talloc_str;
   29686           0 :                         PyObject *unicode = NULL;
   29687           0 :                         if (PyUnicode_Check(value)) {
   29688           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   29689           0 :                                 if (unicode == NULL) {
   29690           0 :                                         return -1;
   29691             :                                 }
   29692           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   29693           0 :                         } else if (PyBytes_Check(value)) {
   29694           0 :                                 test_str = PyBytes_AS_STRING(value);
   29695             :                         } else {
   29696           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   29697           0 :                                 return -1;
   29698             :                         }
   29699           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   29700           0 :                         if (unicode != NULL) {
   29701           0 :                                 Py_DECREF(unicode);
   29702             :                         }
   29703           0 :                         if (talloc_str == NULL) {
   29704           0 :                                 PyErr_NoMemory();
   29705           0 :                                 return -1;
   29706             :                         }
   29707           0 :                         object->in.pszNodeName = talloc_str;
   29708             :                 }
   29709             :         }
   29710           0 :         return 0;
   29711             : }
   29712             : 
   29713           0 : static PyObject *py_DnssrvEnumRecords_in_get_pszStartChild(PyObject *obj, void *closure)
   29714             : {
   29715           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(obj);
   29716           0 :         PyObject *py_pszStartChild;
   29717           0 :         if (object->in.pszStartChild == NULL) {
   29718           0 :                 Py_RETURN_NONE;
   29719             :         }
   29720           0 :         if (object->in.pszStartChild == NULL) {
   29721           0 :                 py_pszStartChild = Py_None;
   29722           0 :                 Py_INCREF(py_pszStartChild);
   29723             :         } else {
   29724           0 :                 if (object->in.pszStartChild == NULL) {
   29725           0 :                         py_pszStartChild = Py_None;
   29726           0 :                         Py_INCREF(py_pszStartChild);
   29727             :                 } else {
   29728           0 :                         py_pszStartChild = PyUnicode_Decode(object->in.pszStartChild, strlen(object->in.pszStartChild), "utf-8", "ignore");
   29729             :                 }
   29730             :         }
   29731           0 :         return py_pszStartChild;
   29732             : }
   29733             : 
   29734           0 : static int py_DnssrvEnumRecords_in_set_pszStartChild(PyObject *py_obj, PyObject *value, void *closure)
   29735             : {
   29736           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(py_obj);
   29737           0 :         if (value == NULL) {
   29738           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszStartChild");
   29739           0 :                 return -1;
   29740             :         }
   29741           0 :         if (value == Py_None) {
   29742           0 :                 object->in.pszStartChild = NULL;
   29743             :         } else {
   29744           0 :                 object->in.pszStartChild = NULL;
   29745             :                 {
   29746           0 :                         const char *test_str;
   29747           0 :                         const char *talloc_str;
   29748           0 :                         PyObject *unicode = NULL;
   29749           0 :                         if (PyUnicode_Check(value)) {
   29750           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   29751           0 :                                 if (unicode == NULL) {
   29752           0 :                                         return -1;
   29753             :                                 }
   29754           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   29755           0 :                         } else if (PyBytes_Check(value)) {
   29756           0 :                                 test_str = PyBytes_AS_STRING(value);
   29757             :                         } else {
   29758           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   29759           0 :                                 return -1;
   29760             :                         }
   29761           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   29762           0 :                         if (unicode != NULL) {
   29763           0 :                                 Py_DECREF(unicode);
   29764             :                         }
   29765           0 :                         if (talloc_str == NULL) {
   29766           0 :                                 PyErr_NoMemory();
   29767           0 :                                 return -1;
   29768             :                         }
   29769           0 :                         object->in.pszStartChild = talloc_str;
   29770             :                 }
   29771             :         }
   29772           0 :         return 0;
   29773             : }
   29774             : 
   29775           0 : static PyObject *py_DnssrvEnumRecords_in_get_wRecordType(PyObject *obj, void *closure)
   29776             : {
   29777           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(obj);
   29778           0 :         PyObject *py_wRecordType;
   29779           0 :         py_wRecordType = PyLong_FromLong((uint16_t)(object->in.wRecordType));
   29780           0 :         return py_wRecordType;
   29781             : }
   29782             : 
   29783           0 : static int py_DnssrvEnumRecords_in_set_wRecordType(PyObject *py_obj, PyObject *value, void *closure)
   29784             : {
   29785           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(py_obj);
   29786           0 :         if (value == NULL) {
   29787           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.wRecordType");
   29788           0 :                 return -1;
   29789             :         }
   29790             :         {
   29791           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.wRecordType));
   29792           0 :                 if (PyLong_Check(value)) {
   29793           0 :                         unsigned long long test_var;
   29794           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   29795           0 :                         if (PyErr_Occurred() != NULL) {
   29796           0 :                                 return -1;
   29797             :                         }
   29798           0 :                         if (test_var > uint_max) {
   29799           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   29800             :                                   PyLong_Type.tp_name, uint_max, test_var);
   29801           0 :                                 return -1;
   29802             :                         }
   29803           0 :                         object->in.wRecordType = test_var;
   29804             :                 } else {
   29805           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   29806             :                           PyLong_Type.tp_name);
   29807           0 :                         return -1;
   29808             :                 }
   29809             :         }
   29810           0 :         return 0;
   29811             : }
   29812             : 
   29813           0 : static PyObject *py_DnssrvEnumRecords_in_get_fSelectFlag(PyObject *obj, void *closure)
   29814             : {
   29815           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(obj);
   29816           0 :         PyObject *py_fSelectFlag;
   29817           0 :         py_fSelectFlag = PyLong_FromUnsignedLongLong((uint32_t)(object->in.fSelectFlag));
   29818           0 :         return py_fSelectFlag;
   29819             : }
   29820             : 
   29821           0 : static int py_DnssrvEnumRecords_in_set_fSelectFlag(PyObject *py_obj, PyObject *value, void *closure)
   29822             : {
   29823           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(py_obj);
   29824           0 :         if (value == NULL) {
   29825           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.fSelectFlag");
   29826           0 :                 return -1;
   29827             :         }
   29828             :         {
   29829           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.fSelectFlag));
   29830           0 :                 if (PyLong_Check(value)) {
   29831           0 :                         unsigned long long test_var;
   29832           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   29833           0 :                         if (PyErr_Occurred() != NULL) {
   29834           0 :                                 return -1;
   29835             :                         }
   29836           0 :                         if (test_var > uint_max) {
   29837           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   29838             :                                   PyLong_Type.tp_name, uint_max, test_var);
   29839           0 :                                 return -1;
   29840             :                         }
   29841           0 :                         object->in.fSelectFlag = test_var;
   29842             :                 } else {
   29843           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   29844             :                           PyLong_Type.tp_name);
   29845           0 :                         return -1;
   29846             :                 }
   29847             :         }
   29848           0 :         return 0;
   29849             : }
   29850             : 
   29851           0 : static PyObject *py_DnssrvEnumRecords_in_get_pszFilterStart(PyObject *obj, void *closure)
   29852             : {
   29853           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(obj);
   29854           0 :         PyObject *py_pszFilterStart;
   29855           0 :         if (object->in.pszFilterStart == NULL) {
   29856           0 :                 Py_RETURN_NONE;
   29857             :         }
   29858           0 :         if (object->in.pszFilterStart == NULL) {
   29859           0 :                 py_pszFilterStart = Py_None;
   29860           0 :                 Py_INCREF(py_pszFilterStart);
   29861             :         } else {
   29862           0 :                 if (object->in.pszFilterStart == NULL) {
   29863           0 :                         py_pszFilterStart = Py_None;
   29864           0 :                         Py_INCREF(py_pszFilterStart);
   29865             :                 } else {
   29866           0 :                         py_pszFilterStart = PyUnicode_Decode(object->in.pszFilterStart, strlen(object->in.pszFilterStart), "utf-8", "ignore");
   29867             :                 }
   29868             :         }
   29869           0 :         return py_pszFilterStart;
   29870             : }
   29871             : 
   29872           0 : static int py_DnssrvEnumRecords_in_set_pszFilterStart(PyObject *py_obj, PyObject *value, void *closure)
   29873             : {
   29874           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(py_obj);
   29875           0 :         if (value == NULL) {
   29876           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszFilterStart");
   29877           0 :                 return -1;
   29878             :         }
   29879           0 :         if (value == Py_None) {
   29880           0 :                 object->in.pszFilterStart = NULL;
   29881             :         } else {
   29882           0 :                 object->in.pszFilterStart = NULL;
   29883             :                 {
   29884           0 :                         const char *test_str;
   29885           0 :                         const char *talloc_str;
   29886           0 :                         PyObject *unicode = NULL;
   29887           0 :                         if (PyUnicode_Check(value)) {
   29888           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   29889           0 :                                 if (unicode == NULL) {
   29890           0 :                                         return -1;
   29891             :                                 }
   29892           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   29893           0 :                         } else if (PyBytes_Check(value)) {
   29894           0 :                                 test_str = PyBytes_AS_STRING(value);
   29895             :                         } else {
   29896           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   29897           0 :                                 return -1;
   29898             :                         }
   29899           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   29900           0 :                         if (unicode != NULL) {
   29901           0 :                                 Py_DECREF(unicode);
   29902             :                         }
   29903           0 :                         if (talloc_str == NULL) {
   29904           0 :                                 PyErr_NoMemory();
   29905           0 :                                 return -1;
   29906             :                         }
   29907           0 :                         object->in.pszFilterStart = talloc_str;
   29908             :                 }
   29909             :         }
   29910           0 :         return 0;
   29911             : }
   29912             : 
   29913           0 : static PyObject *py_DnssrvEnumRecords_in_get_pszFilterStop(PyObject *obj, void *closure)
   29914             : {
   29915           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(obj);
   29916           0 :         PyObject *py_pszFilterStop;
   29917           0 :         if (object->in.pszFilterStop == NULL) {
   29918           0 :                 Py_RETURN_NONE;
   29919             :         }
   29920           0 :         if (object->in.pszFilterStop == NULL) {
   29921           0 :                 py_pszFilterStop = Py_None;
   29922           0 :                 Py_INCREF(py_pszFilterStop);
   29923             :         } else {
   29924           0 :                 if (object->in.pszFilterStop == NULL) {
   29925           0 :                         py_pszFilterStop = Py_None;
   29926           0 :                         Py_INCREF(py_pszFilterStop);
   29927             :                 } else {
   29928           0 :                         py_pszFilterStop = PyUnicode_Decode(object->in.pszFilterStop, strlen(object->in.pszFilterStop), "utf-8", "ignore");
   29929             :                 }
   29930             :         }
   29931           0 :         return py_pszFilterStop;
   29932             : }
   29933             : 
   29934           0 : static int py_DnssrvEnumRecords_in_set_pszFilterStop(PyObject *py_obj, PyObject *value, void *closure)
   29935             : {
   29936           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(py_obj);
   29937           0 :         if (value == NULL) {
   29938           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszFilterStop");
   29939           0 :                 return -1;
   29940             :         }
   29941           0 :         if (value == Py_None) {
   29942           0 :                 object->in.pszFilterStop = NULL;
   29943             :         } else {
   29944           0 :                 object->in.pszFilterStop = NULL;
   29945             :                 {
   29946           0 :                         const char *test_str;
   29947           0 :                         const char *talloc_str;
   29948           0 :                         PyObject *unicode = NULL;
   29949           0 :                         if (PyUnicode_Check(value)) {
   29950           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   29951           0 :                                 if (unicode == NULL) {
   29952           0 :                                         return -1;
   29953             :                                 }
   29954           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   29955           0 :                         } else if (PyBytes_Check(value)) {
   29956           0 :                                 test_str = PyBytes_AS_STRING(value);
   29957             :                         } else {
   29958           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   29959           0 :                                 return -1;
   29960             :                         }
   29961           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   29962           0 :                         if (unicode != NULL) {
   29963           0 :                                 Py_DECREF(unicode);
   29964             :                         }
   29965           0 :                         if (talloc_str == NULL) {
   29966           0 :                                 PyErr_NoMemory();
   29967           0 :                                 return -1;
   29968             :                         }
   29969           0 :                         object->in.pszFilterStop = talloc_str;
   29970             :                 }
   29971             :         }
   29972           0 :         return 0;
   29973             : }
   29974             : 
   29975           0 : static PyObject *py_DnssrvEnumRecords_out_get_pdwBufferLength(PyObject *obj, void *closure)
   29976             : {
   29977           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(obj);
   29978           0 :         PyObject *py_pdwBufferLength;
   29979           0 :         if (object->out.pdwBufferLength == NULL) {
   29980           0 :                 Py_RETURN_NONE;
   29981             :         }
   29982           0 :         py_pdwBufferLength = PyLong_FromUnsignedLongLong((uint32_t)(*object->out.pdwBufferLength));
   29983           0 :         return py_pdwBufferLength;
   29984             : }
   29985             : 
   29986           0 : static int py_DnssrvEnumRecords_out_set_pdwBufferLength(PyObject *py_obj, PyObject *value, void *closure)
   29987             : {
   29988           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(py_obj);
   29989           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.pdwBufferLength));
   29990           0 :         if (value == NULL) {
   29991           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.pdwBufferLength");
   29992           0 :                 return -1;
   29993             :         }
   29994           0 :         object->out.pdwBufferLength = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.pdwBufferLength);
   29995           0 :         if (object->out.pdwBufferLength == NULL) {
   29996           0 :                 PyErr_NoMemory();
   29997           0 :                 return -1;
   29998             :         }
   29999             :         {
   30000           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->out.pdwBufferLength));
   30001           0 :                 if (PyLong_Check(value)) {
   30002           0 :                         unsigned long long test_var;
   30003           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   30004           0 :                         if (PyErr_Occurred() != NULL) {
   30005           0 :                                 return -1;
   30006             :                         }
   30007           0 :                         if (test_var > uint_max) {
   30008           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   30009             :                                   PyLong_Type.tp_name, uint_max, test_var);
   30010           0 :                                 return -1;
   30011             :                         }
   30012           0 :                         *object->out.pdwBufferLength = test_var;
   30013             :                 } else {
   30014           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   30015             :                           PyLong_Type.tp_name);
   30016           0 :                         return -1;
   30017             :                 }
   30018             :         }
   30019           0 :         return 0;
   30020             : }
   30021             : 
   30022           0 : static PyObject *py_DnssrvEnumRecords_out_get_pBuffer(PyObject *obj, void *closure)
   30023             : {
   30024           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(obj);
   30025           0 :         PyObject *py_pBuffer;
   30026           0 :         if (object->out.pBuffer == NULL) {
   30027           0 :                 Py_RETURN_NONE;
   30028             :         }
   30029           0 :         if (*object->out.pBuffer == NULL) {
   30030           0 :                 py_pBuffer = Py_None;
   30031           0 :                 Py_INCREF(py_pBuffer);
   30032             :         } else {
   30033           0 :                 py_pBuffer = pytalloc_reference_ex(&DNS_RPC_RECORDS_ARRAY_Type, *object->out.pBuffer, *object->out.pBuffer);
   30034             :         }
   30035           0 :         return py_pBuffer;
   30036             : }
   30037             : 
   30038           0 : static int py_DnssrvEnumRecords_out_set_pBuffer(PyObject *py_obj, PyObject *value, void *closure)
   30039             : {
   30040           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(py_obj);
   30041           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.pBuffer));
   30042           0 :         if (value == NULL) {
   30043           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.pBuffer");
   30044           0 :                 return -1;
   30045             :         }
   30046           0 :         object->out.pBuffer = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.pBuffer);
   30047           0 :         if (object->out.pBuffer == NULL) {
   30048           0 :                 PyErr_NoMemory();
   30049           0 :                 return -1;
   30050             :         }
   30051           0 :         if (value == Py_None) {
   30052           0 :                 *object->out.pBuffer = NULL;
   30053             :         } else {
   30054           0 :                 *object->out.pBuffer = NULL;
   30055           0 :                 PY_CHECK_TYPE(&DNS_RPC_RECORDS_ARRAY_Type, value, return -1;);
   30056           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   30057           0 :                         PyErr_NoMemory();
   30058           0 :                         return -1;
   30059             :                 }
   30060           0 :                 *object->out.pBuffer = (struct DNS_RPC_RECORDS_ARRAY *)pytalloc_get_ptr(value);
   30061             :         }
   30062           0 :         return 0;
   30063             : }
   30064             : 
   30065           0 : static PyObject *py_DnssrvEnumRecords_get_result(PyObject *obj, void *closure)
   30066             : {
   30067           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(obj);
   30068           0 :         PyObject *py_result;
   30069           0 :         py_result = PyErr_FromWERROR(object->out.result);
   30070           0 :         return py_result;
   30071             : }
   30072             : 
   30073           0 : static int py_DnssrvEnumRecords_set_result(PyObject *py_obj, PyObject *value, void *closure)
   30074             : {
   30075           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(py_obj);
   30076           0 :         if (value == NULL) {
   30077           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.result");
   30078           0 :                 return -1;
   30079             :         }
   30080           0 :         object->out.result = W_ERROR(PyLong_AsLong(value));
   30081           0 :         return 0;
   30082             : }
   30083             : 
   30084             : static PyGetSetDef py_DnssrvEnumRecords_getsetters[] = {
   30085             :         {
   30086             :                 .name = discard_const_p(char, "in_pwszServerName"),
   30087             :                 .get = py_DnssrvEnumRecords_in_get_pwszServerName,
   30088             :                 .set = py_DnssrvEnumRecords_in_set_pwszServerName,
   30089             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
   30090             :         },
   30091             :         {
   30092             :                 .name = discard_const_p(char, "in_pszZone"),
   30093             :                 .get = py_DnssrvEnumRecords_in_get_pszZone,
   30094             :                 .set = py_DnssrvEnumRecords_in_set_pszZone,
   30095             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   30096             :         },
   30097             :         {
   30098             :                 .name = discard_const_p(char, "in_pszNodeName"),
   30099             :                 .get = py_DnssrvEnumRecords_in_get_pszNodeName,
   30100             :                 .set = py_DnssrvEnumRecords_in_set_pszNodeName,
   30101             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   30102             :         },
   30103             :         {
   30104             :                 .name = discard_const_p(char, "in_pszStartChild"),
   30105             :                 .get = py_DnssrvEnumRecords_in_get_pszStartChild,
   30106             :                 .set = py_DnssrvEnumRecords_in_set_pszStartChild,
   30107             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   30108             :         },
   30109             :         {
   30110             :                 .name = discard_const_p(char, "in_wRecordType"),
   30111             :                 .get = py_DnssrvEnumRecords_in_get_wRecordType,
   30112             :                 .set = py_DnssrvEnumRecords_in_set_wRecordType,
   30113             :                 .doc = discard_const_p(char, "PIDL-generated element of base type dns_record_type")
   30114             :         },
   30115             :         {
   30116             :                 .name = discard_const_p(char, "in_fSelectFlag"),
   30117             :                 .get = py_DnssrvEnumRecords_in_get_fSelectFlag,
   30118             :                 .set = py_DnssrvEnumRecords_in_set_fSelectFlag,
   30119             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_SELECT_FLAGS")
   30120             :         },
   30121             :         {
   30122             :                 .name = discard_const_p(char, "in_pszFilterStart"),
   30123             :                 .get = py_DnssrvEnumRecords_in_get_pszFilterStart,
   30124             :                 .set = py_DnssrvEnumRecords_in_set_pszFilterStart,
   30125             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   30126             :         },
   30127             :         {
   30128             :                 .name = discard_const_p(char, "in_pszFilterStop"),
   30129             :                 .get = py_DnssrvEnumRecords_in_get_pszFilterStop,
   30130             :                 .set = py_DnssrvEnumRecords_in_set_pszFilterStop,
   30131             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   30132             :         },
   30133             :         {
   30134             :                 .name = discard_const_p(char, "out_pdwBufferLength"),
   30135             :                 .get = py_DnssrvEnumRecords_out_get_pdwBufferLength,
   30136             :                 .set = py_DnssrvEnumRecords_out_set_pdwBufferLength,
   30137             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   30138             :         },
   30139             :         {
   30140             :                 .name = discard_const_p(char, "out_pBuffer"),
   30141             :                 .get = py_DnssrvEnumRecords_out_get_pBuffer,
   30142             :                 .set = py_DnssrvEnumRecords_out_set_pBuffer,
   30143             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_RECORDS_ARRAY")
   30144             :         },
   30145             :         {
   30146             :                 .name = discard_const_p(char, "result"),
   30147             :                 .get = py_DnssrvEnumRecords_get_result,
   30148             :                 .set = py_DnssrvEnumRecords_set_result,
   30149             :                 .doc = discard_const_p(char, "PIDL-generated element of type WERROR")
   30150             :         },
   30151             :         { .name = NULL }
   30152             : };
   30153             : 
   30154           0 : static PyObject *py_DnssrvEnumRecords_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   30155             : {
   30156           0 :         PyObject *self = pytalloc_new(struct DnssrvEnumRecords, type);
   30157           0 :         struct DnssrvEnumRecords *_self = (struct DnssrvEnumRecords *)pytalloc_get_ptr(self);
   30158           0 :         TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
   30159           0 :         _self->out.pdwBufferLength = talloc_zero(mem_ctx, uint32_t);
   30160             :         /* a pointer to a NULL pointer */
   30161           0 :         _self->out.pBuffer = talloc_zero(mem_ctx, struct DNS_RPC_RECORDS_ARRAY *);
   30162           0 :         return self;
   30163             : }
   30164             : 
   30165           0 : static PyObject *py_DnssrvEnumRecords_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
   30166             : {
   30167             : 
   30168             : 
   30169           0 :         return PyLong_FromLong(3);
   30170             : }
   30171             : 
   30172           0 : static PyObject *py_DnssrvEnumRecords_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
   30173             : {
   30174           0 :         const struct ndr_interface_call *call = NULL;
   30175           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(py_obj);
   30176           0 :         PyObject *ret = NULL;
   30177           0 :         struct ndr_push *push = NULL;
   30178           0 :         DATA_BLOB blob;
   30179           0 :         enum ndr_err_code err;
   30180             : 
   30181           0 :         if (ndr_table_dnsserver.num_calls < 4) {
   30182           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvEnumRecords_ndr_pack");
   30183           0 :                 return NULL;
   30184             :         }
   30185           0 :         call = &ndr_table_dnsserver.calls[3];
   30186             : 
   30187           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
   30188           0 :         if (push == NULL) {
   30189           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
   30190           0 :                 return NULL;
   30191             :         }
   30192             : 
   30193           0 :         push->flags |= ndr_push_flags;
   30194             : 
   30195           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
   30196           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   30197           0 :                 TALLOC_FREE(push);
   30198           0 :                 PyErr_SetNdrError(err);
   30199           0 :                 return NULL;
   30200             :         }
   30201           0 :         blob = ndr_push_blob(push);
   30202           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
   30203           0 :         TALLOC_FREE(push);
   30204           0 :         return ret;
   30205             : }
   30206             : 
   30207           0 : static PyObject *py_DnssrvEnumRecords_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   30208             : {
   30209           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
   30210           0 :         PyObject *bigendian_obj = NULL;
   30211           0 :         PyObject *ndr64_obj = NULL;
   30212           0 :         libndr_flags ndr_push_flags = 0;
   30213             : 
   30214           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
   30215             :                 discard_const_p(char *, kwnames),
   30216             :                 &bigendian_obj,
   30217             :                 &ndr64_obj)) {
   30218           0 :                 return NULL;
   30219             :         }
   30220             : 
   30221           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   30222           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
   30223             :         }
   30224           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   30225           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
   30226             :         }
   30227             : 
   30228           0 :         return py_DnssrvEnumRecords_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
   30229             : }
   30230             : 
   30231           0 : static PyObject *py_DnssrvEnumRecords_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   30232             : {
   30233           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
   30234           0 :         PyObject *bigendian_obj = NULL;
   30235           0 :         PyObject *ndr64_obj = NULL;
   30236           0 :         libndr_flags ndr_push_flags = 0;
   30237             : 
   30238           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
   30239             :                 discard_const_p(char *, kwnames),
   30240             :                 &bigendian_obj,
   30241             :                 &ndr64_obj)) {
   30242           0 :                 return NULL;
   30243             :         }
   30244             : 
   30245           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   30246           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
   30247             :         }
   30248           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   30249           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
   30250             :         }
   30251             : 
   30252           0 :         return py_DnssrvEnumRecords_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
   30253             : }
   30254             : 
   30255           0 : static PyObject *py_DnssrvEnumRecords_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
   30256             : {
   30257           0 :         const struct ndr_interface_call *call = NULL;
   30258           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(py_obj);
   30259           0 :         struct ndr_pull *pull = NULL;
   30260           0 :         enum ndr_err_code err;
   30261             : 
   30262           0 :         if (ndr_table_dnsserver.num_calls < 4) {
   30263           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvEnumRecords_ndr_unpack");
   30264           0 :                 return NULL;
   30265             :         }
   30266           0 :         call = &ndr_table_dnsserver.calls[3];
   30267             : 
   30268           0 :         pull = ndr_pull_init_blob(blob, object);
   30269           0 :         if (pull == NULL) {
   30270           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
   30271           0 :                 return NULL;
   30272             :         }
   30273             : 
   30274           0 :         pull->flags |= ndr_pull_flags;
   30275             : 
   30276           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
   30277           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   30278           0 :                 TALLOC_FREE(pull);
   30279           0 :                 PyErr_SetNdrError(err);
   30280           0 :                 return NULL;
   30281             :         }
   30282           0 :         if (!allow_remaining) {
   30283           0 :                 uint32_t highest_ofs;
   30284             : 
   30285           0 :                 if (pull->offset > pull->relative_highest_offset) {
   30286           0 :                         highest_ofs = pull->offset;
   30287             :                 } else {
   30288           0 :                         highest_ofs = pull->relative_highest_offset;
   30289             :                 }
   30290           0 :                 if (highest_ofs < pull->data_size) {
   30291           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
   30292             :                                 "not all bytes consumed ofs[%u] size[%u]",
   30293             :                                 highest_ofs, pull->data_size);
   30294           0 :                         TALLOC_FREE(pull);
   30295           0 :                         PyErr_SetNdrError(err);
   30296           0 :                         return NULL;
   30297             :                 }
   30298             :         }
   30299             : 
   30300           0 :         TALLOC_FREE(pull);
   30301           0 :         Py_RETURN_NONE;
   30302             : }
   30303             : 
   30304           0 : static PyObject *py_DnssrvEnumRecords_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   30305             : {
   30306           0 :         DATA_BLOB blob;
   30307           0 :         Py_ssize_t blob_length = 0;
   30308           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
   30309           0 :         PyObject *bigendian_obj = NULL;
   30310           0 :         PyObject *ndr64_obj = NULL;
   30311           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
   30312           0 :         PyObject *allow_remaining_obj = NULL;
   30313           0 :         bool allow_remaining = false;
   30314             : 
   30315           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
   30316             :                 discard_const_p(char *, kwnames),
   30317             :                 &blob.data, &blob_length,
   30318             :                 &bigendian_obj,
   30319             :                 &ndr64_obj,
   30320             :                 &allow_remaining_obj)) {
   30321           0 :                 return NULL;
   30322             :         }
   30323           0 :         blob.length = blob_length;
   30324             : 
   30325           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   30326           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
   30327             :         }
   30328           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   30329           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
   30330             :         }
   30331             : 
   30332           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
   30333           0 :                 allow_remaining = true;
   30334             :         }
   30335             : 
   30336           0 :         return py_DnssrvEnumRecords_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
   30337             : }
   30338             : 
   30339           0 : static PyObject *py_DnssrvEnumRecords_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   30340             : {
   30341           0 :         DATA_BLOB blob;
   30342           0 :         Py_ssize_t blob_length = 0;
   30343           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
   30344           0 :         PyObject *bigendian_obj = NULL;
   30345           0 :         PyObject *ndr64_obj = NULL;
   30346           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
   30347           0 :         PyObject *allow_remaining_obj = NULL;
   30348           0 :         bool allow_remaining = false;
   30349             : 
   30350           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
   30351             :                 discard_const_p(char *, kwnames),
   30352             :                 &blob.data, &blob_length,
   30353             :                 &bigendian_obj,
   30354             :                 &ndr64_obj,
   30355             :                 &allow_remaining_obj)) {
   30356           0 :                 return NULL;
   30357             :         }
   30358           0 :         blob.length = blob_length;
   30359             : 
   30360           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   30361           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
   30362             :         }
   30363           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   30364           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
   30365             :         }
   30366             : 
   30367           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
   30368           0 :                 allow_remaining = true;
   30369             :         }
   30370             : 
   30371           0 :         return py_DnssrvEnumRecords_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
   30372             : }
   30373             : 
   30374           0 : static PyObject *py_DnssrvEnumRecords_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
   30375             : {
   30376           0 :         const struct ndr_interface_call *call = NULL;
   30377           0 :         struct DnssrvEnumRecords *object = pytalloc_get_ptr(py_obj);
   30378           0 :         PyObject *ret;
   30379           0 :         char *retstr;
   30380             : 
   30381           0 :         if (ndr_table_dnsserver.num_calls < 4) {
   30382           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvEnumRecords_ndr_print");
   30383           0 :                 return NULL;
   30384             :         }
   30385           0 :         call = &ndr_table_dnsserver.calls[3];
   30386             : 
   30387           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
   30388           0 :         ret = PyUnicode_FromString(retstr);
   30389           0 :         TALLOC_FREE(retstr);
   30390             : 
   30391           0 :         return ret;
   30392             : }
   30393             : 
   30394           0 : static PyObject *py_DnssrvEnumRecords_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
   30395             : {
   30396           0 :         return py_DnssrvEnumRecords_ndr_print(py_obj, "DnssrvEnumRecords_in", NDR_IN);
   30397             : }
   30398             : 
   30399           0 : static PyObject *py_DnssrvEnumRecords_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
   30400             : {
   30401           0 :         return py_DnssrvEnumRecords_ndr_print(py_obj, "DnssrvEnumRecords_out", NDR_OUT);
   30402             : }
   30403             : 
   30404             : static PyMethodDef py_DnssrvEnumRecords_methods[] = {
   30405             :         { "opnum", (PyCFunction)py_DnssrvEnumRecords_ndr_opnum, METH_NOARGS|METH_CLASS,
   30406             :                 "dnsserver.DnssrvEnumRecords.opnum() -> 3 (0x03) " },
   30407             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvEnumRecords_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
   30408             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
   30409             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvEnumRecords_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
   30410             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
   30411             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvEnumRecords_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
   30412             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
   30413             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvEnumRecords_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
   30414             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
   30415             :         { "__ndr_print_in__", (PyCFunction)py_DnssrvEnumRecords_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
   30416             :         { "__ndr_print_out__", (PyCFunction)py_DnssrvEnumRecords_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
   30417             :         { NULL, NULL, 0, NULL }
   30418             : };
   30419             : 
   30420             : 
   30421             : static PyTypeObject DnssrvEnumRecords_Type = {
   30422             :         PyVarObject_HEAD_INIT(NULL, 0)
   30423             :         .tp_name = "dnsserver.DnssrvEnumRecords",
   30424             :         .tp_getset = py_DnssrvEnumRecords_getsetters,
   30425             :         .tp_methods = py_DnssrvEnumRecords_methods,
   30426             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   30427             :         .tp_new = py_DnssrvEnumRecords_new,
   30428             : };
   30429             : 
   30430           0 : static bool pack_py_DnssrvEnumRecords_args_in(PyObject *args, PyObject *kwargs, struct DnssrvEnumRecords *r)
   30431             : {
   30432           0 :         PyObject *py_pwszServerName;
   30433           0 :         PyObject *py_pszZone;
   30434           0 :         PyObject *py_pszNodeName;
   30435           0 :         PyObject *py_pszStartChild;
   30436           0 :         PyObject *py_wRecordType;
   30437           0 :         PyObject *py_fSelectFlag;
   30438           0 :         PyObject *py_pszFilterStart;
   30439           0 :         PyObject *py_pszFilterStop;
   30440           0 :         const char *kwnames[] = {
   30441             :                 "pwszServerName", "pszZone", "pszNodeName", "pszStartChild", "wRecordType", "fSelectFlag", "pszFilterStart", "pszFilterStop", NULL
   30442             :         };
   30443             : 
   30444           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOO:DnssrvEnumRecords", discard_const_p(char *, kwnames), &py_pwszServerName, &py_pszZone, &py_pszNodeName, &py_pszStartChild, &py_wRecordType, &py_fSelectFlag, &py_pszFilterStart, &py_pszFilterStop)) {
   30445           0 :                 return false;
   30446             :         }
   30447             : 
   30448           0 :         if (py_pwszServerName == NULL) {
   30449           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pwszServerName");
   30450           0 :                 return false;
   30451             :         }
   30452           0 :         if (py_pwszServerName == Py_None) {
   30453           0 :                 r->in.pwszServerName = NULL;
   30454             :         } else {
   30455           0 :                 r->in.pwszServerName = NULL;
   30456             :                 {
   30457           0 :                         const char *test_str;
   30458           0 :                         const char *talloc_str;
   30459           0 :                         PyObject *unicode = NULL;
   30460           0 :                         if (PyUnicode_Check(py_pwszServerName)) {
   30461           0 :                                 unicode = PyUnicode_AsEncodedString(py_pwszServerName, "utf-8", "ignore");
   30462           0 :                                 if (unicode == NULL) {
   30463           0 :                                         return false;
   30464             :                                 }
   30465           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   30466           0 :                         } else if (PyBytes_Check(py_pwszServerName)) {
   30467           0 :                                 test_str = PyBytes_AS_STRING(py_pwszServerName);
   30468             :                         } else {
   30469           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pwszServerName)->tp_name);
   30470           0 :                                 return false;
   30471             :                         }
   30472           0 :                         talloc_str = talloc_strdup(r, test_str);
   30473           0 :                         if (unicode != NULL) {
   30474           0 :                                 Py_DECREF(unicode);
   30475             :                         }
   30476           0 :                         if (talloc_str == NULL) {
   30477           0 :                                 PyErr_NoMemory();
   30478           0 :                                 return false;
   30479             :                         }
   30480           0 :                         r->in.pwszServerName = talloc_str;
   30481             :                 }
   30482             :         }
   30483           0 :         if (py_pszZone == NULL) {
   30484           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszZone");
   30485           0 :                 return false;
   30486             :         }
   30487           0 :         if (py_pszZone == Py_None) {
   30488           0 :                 r->in.pszZone = NULL;
   30489             :         } else {
   30490           0 :                 r->in.pszZone = NULL;
   30491             :                 {
   30492           0 :                         const char *test_str;
   30493           0 :                         const char *talloc_str;
   30494           0 :                         PyObject *unicode = NULL;
   30495           0 :                         if (PyUnicode_Check(py_pszZone)) {
   30496           0 :                                 unicode = PyUnicode_AsEncodedString(py_pszZone, "utf-8", "ignore");
   30497           0 :                                 if (unicode == NULL) {
   30498           0 :                                         return false;
   30499             :                                 }
   30500           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   30501           0 :                         } else if (PyBytes_Check(py_pszZone)) {
   30502           0 :                                 test_str = PyBytes_AS_STRING(py_pszZone);
   30503             :                         } else {
   30504           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszZone)->tp_name);
   30505           0 :                                 return false;
   30506             :                         }
   30507           0 :                         talloc_str = talloc_strdup(r, test_str);
   30508           0 :                         if (unicode != NULL) {
   30509           0 :                                 Py_DECREF(unicode);
   30510             :                         }
   30511           0 :                         if (talloc_str == NULL) {
   30512           0 :                                 PyErr_NoMemory();
   30513           0 :                                 return false;
   30514             :                         }
   30515           0 :                         r->in.pszZone = talloc_str;
   30516             :                 }
   30517             :         }
   30518           0 :         if (py_pszNodeName == NULL) {
   30519           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszNodeName");
   30520           0 :                 return false;
   30521             :         }
   30522           0 :         if (py_pszNodeName == Py_None) {
   30523           0 :                 r->in.pszNodeName = NULL;
   30524             :         } else {
   30525           0 :                 r->in.pszNodeName = NULL;
   30526             :                 {
   30527           0 :                         const char *test_str;
   30528           0 :                         const char *talloc_str;
   30529           0 :                         PyObject *unicode = NULL;
   30530           0 :                         if (PyUnicode_Check(py_pszNodeName)) {
   30531           0 :                                 unicode = PyUnicode_AsEncodedString(py_pszNodeName, "utf-8", "ignore");
   30532           0 :                                 if (unicode == NULL) {
   30533           0 :                                         return false;
   30534             :                                 }
   30535           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   30536           0 :                         } else if (PyBytes_Check(py_pszNodeName)) {
   30537           0 :                                 test_str = PyBytes_AS_STRING(py_pszNodeName);
   30538             :                         } else {
   30539           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszNodeName)->tp_name);
   30540           0 :                                 return false;
   30541             :                         }
   30542           0 :                         talloc_str = talloc_strdup(r, test_str);
   30543           0 :                         if (unicode != NULL) {
   30544           0 :                                 Py_DECREF(unicode);
   30545             :                         }
   30546           0 :                         if (talloc_str == NULL) {
   30547           0 :                                 PyErr_NoMemory();
   30548           0 :                                 return false;
   30549             :                         }
   30550           0 :                         r->in.pszNodeName = talloc_str;
   30551             :                 }
   30552             :         }
   30553           0 :         if (py_pszStartChild == NULL) {
   30554           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszStartChild");
   30555           0 :                 return false;
   30556             :         }
   30557           0 :         if (py_pszStartChild == Py_None) {
   30558           0 :                 r->in.pszStartChild = NULL;
   30559             :         } else {
   30560           0 :                 r->in.pszStartChild = NULL;
   30561             :                 {
   30562           0 :                         const char *test_str;
   30563           0 :                         const char *talloc_str;
   30564           0 :                         PyObject *unicode = NULL;
   30565           0 :                         if (PyUnicode_Check(py_pszStartChild)) {
   30566           0 :                                 unicode = PyUnicode_AsEncodedString(py_pszStartChild, "utf-8", "ignore");
   30567           0 :                                 if (unicode == NULL) {
   30568           0 :                                         return false;
   30569             :                                 }
   30570           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   30571           0 :                         } else if (PyBytes_Check(py_pszStartChild)) {
   30572           0 :                                 test_str = PyBytes_AS_STRING(py_pszStartChild);
   30573             :                         } else {
   30574           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszStartChild)->tp_name);
   30575           0 :                                 return false;
   30576             :                         }
   30577           0 :                         talloc_str = talloc_strdup(r, test_str);
   30578           0 :                         if (unicode != NULL) {
   30579           0 :                                 Py_DECREF(unicode);
   30580             :                         }
   30581           0 :                         if (talloc_str == NULL) {
   30582           0 :                                 PyErr_NoMemory();
   30583           0 :                                 return false;
   30584             :                         }
   30585           0 :                         r->in.pszStartChild = talloc_str;
   30586             :                 }
   30587             :         }
   30588           0 :         if (py_wRecordType == NULL) {
   30589           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.wRecordType");
   30590           0 :                 return false;
   30591             :         }
   30592             :         {
   30593           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.wRecordType));
   30594           0 :                 if (PyLong_Check(py_wRecordType)) {
   30595           0 :                         unsigned long long test_var;
   30596           0 :                         test_var = PyLong_AsUnsignedLongLong(py_wRecordType);
   30597           0 :                         if (PyErr_Occurred() != NULL) {
   30598           0 :                                 return false;
   30599             :                         }
   30600           0 :                         if (test_var > uint_max) {
   30601           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   30602             :                                   PyLong_Type.tp_name, uint_max, test_var);
   30603           0 :                                 return false;
   30604             :                         }
   30605           0 :                         r->in.wRecordType = test_var;
   30606             :                 } else {
   30607           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   30608             :                           PyLong_Type.tp_name);
   30609           0 :                         return false;
   30610             :                 }
   30611             :         }
   30612           0 :         if (py_fSelectFlag == NULL) {
   30613           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.fSelectFlag");
   30614           0 :                 return false;
   30615             :         }
   30616             :         {
   30617           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.fSelectFlag));
   30618           0 :                 if (PyLong_Check(py_fSelectFlag)) {
   30619           0 :                         unsigned long long test_var;
   30620           0 :                         test_var = PyLong_AsUnsignedLongLong(py_fSelectFlag);
   30621           0 :                         if (PyErr_Occurred() != NULL) {
   30622           0 :                                 return false;
   30623             :                         }
   30624           0 :                         if (test_var > uint_max) {
   30625           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   30626             :                                   PyLong_Type.tp_name, uint_max, test_var);
   30627           0 :                                 return false;
   30628             :                         }
   30629           0 :                         r->in.fSelectFlag = test_var;
   30630             :                 } else {
   30631           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   30632             :                           PyLong_Type.tp_name);
   30633           0 :                         return false;
   30634             :                 }
   30635             :         }
   30636           0 :         if (py_pszFilterStart == NULL) {
   30637           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszFilterStart");
   30638           0 :                 return false;
   30639             :         }
   30640           0 :         if (py_pszFilterStart == Py_None) {
   30641           0 :                 r->in.pszFilterStart = NULL;
   30642             :         } else {
   30643           0 :                 r->in.pszFilterStart = NULL;
   30644             :                 {
   30645           0 :                         const char *test_str;
   30646           0 :                         const char *talloc_str;
   30647           0 :                         PyObject *unicode = NULL;
   30648           0 :                         if (PyUnicode_Check(py_pszFilterStart)) {
   30649           0 :                                 unicode = PyUnicode_AsEncodedString(py_pszFilterStart, "utf-8", "ignore");
   30650           0 :                                 if (unicode == NULL) {
   30651           0 :                                         return false;
   30652             :                                 }
   30653           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   30654           0 :                         } else if (PyBytes_Check(py_pszFilterStart)) {
   30655           0 :                                 test_str = PyBytes_AS_STRING(py_pszFilterStart);
   30656             :                         } else {
   30657           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszFilterStart)->tp_name);
   30658           0 :                                 return false;
   30659             :                         }
   30660           0 :                         talloc_str = talloc_strdup(r, test_str);
   30661           0 :                         if (unicode != NULL) {
   30662           0 :                                 Py_DECREF(unicode);
   30663             :                         }
   30664           0 :                         if (talloc_str == NULL) {
   30665           0 :                                 PyErr_NoMemory();
   30666           0 :                                 return false;
   30667             :                         }
   30668           0 :                         r->in.pszFilterStart = talloc_str;
   30669             :                 }
   30670             :         }
   30671           0 :         if (py_pszFilterStop == NULL) {
   30672           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszFilterStop");
   30673           0 :                 return false;
   30674             :         }
   30675           0 :         if (py_pszFilterStop == Py_None) {
   30676           0 :                 r->in.pszFilterStop = NULL;
   30677             :         } else {
   30678           0 :                 r->in.pszFilterStop = NULL;
   30679             :                 {
   30680           0 :                         const char *test_str;
   30681           0 :                         const char *talloc_str;
   30682           0 :                         PyObject *unicode = NULL;
   30683           0 :                         if (PyUnicode_Check(py_pszFilterStop)) {
   30684           0 :                                 unicode = PyUnicode_AsEncodedString(py_pszFilterStop, "utf-8", "ignore");
   30685           0 :                                 if (unicode == NULL) {
   30686           0 :                                         return false;
   30687             :                                 }
   30688           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   30689           0 :                         } else if (PyBytes_Check(py_pszFilterStop)) {
   30690           0 :                                 test_str = PyBytes_AS_STRING(py_pszFilterStop);
   30691             :                         } else {
   30692           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszFilterStop)->tp_name);
   30693           0 :                                 return false;
   30694             :                         }
   30695           0 :                         talloc_str = talloc_strdup(r, test_str);
   30696           0 :                         if (unicode != NULL) {
   30697           0 :                                 Py_DECREF(unicode);
   30698             :                         }
   30699           0 :                         if (talloc_str == NULL) {
   30700           0 :                                 PyErr_NoMemory();
   30701           0 :                                 return false;
   30702             :                         }
   30703           0 :                         r->in.pszFilterStop = talloc_str;
   30704             :                 }
   30705             :         }
   30706           0 :         return true;
   30707             : }
   30708             : 
   30709           0 : static PyObject *unpack_py_DnssrvEnumRecords_args_out(struct DnssrvEnumRecords *r)
   30710             : {
   30711           0 :         PyObject *result;
   30712           0 :         PyObject *py_pdwBufferLength;
   30713           0 :         PyObject *py_pBuffer;
   30714           0 :         result = PyTuple_New(2);
   30715           0 :         py_pdwBufferLength = PyLong_FromUnsignedLongLong((uint32_t)(*r->out.pdwBufferLength));
   30716           0 :         PyTuple_SetItem(result, 0, py_pdwBufferLength);
   30717           0 :         if (*r->out.pBuffer == NULL) {
   30718           0 :                 py_pBuffer = Py_None;
   30719           0 :                 Py_INCREF(py_pBuffer);
   30720             :         } else {
   30721           0 :                 py_pBuffer = pytalloc_reference_ex(&DNS_RPC_RECORDS_ARRAY_Type, *r->out.pBuffer, *r->out.pBuffer);
   30722             :         }
   30723           0 :         PyTuple_SetItem(result, 1, py_pBuffer);
   30724           0 :         if (!W_ERROR_IS_OK(r->out.result)) {
   30725           0 :                 PyErr_SetWERROR(r->out.result);
   30726           0 :                 return NULL;
   30727             :         }
   30728             : 
   30729           0 :         return result;
   30730             : }
   30731             : 
   30732             : 
   30733           0 : static PyObject *py_DnssrvUpdateRecord_in_get_pwszServerName(PyObject *obj, void *closure)
   30734             : {
   30735           0 :         struct DnssrvUpdateRecord *object = pytalloc_get_ptr(obj);
   30736           0 :         PyObject *py_pwszServerName;
   30737           0 :         if (object->in.pwszServerName == NULL) {
   30738           0 :                 Py_RETURN_NONE;
   30739             :         }
   30740           0 :         if (object->in.pwszServerName == NULL) {
   30741           0 :                 py_pwszServerName = Py_None;
   30742           0 :                 Py_INCREF(py_pwszServerName);
   30743             :         } else {
   30744           0 :                 if (object->in.pwszServerName == NULL) {
   30745           0 :                         py_pwszServerName = Py_None;
   30746           0 :                         Py_INCREF(py_pwszServerName);
   30747             :                 } else {
   30748           0 :                         py_pwszServerName = PyUnicode_Decode(object->in.pwszServerName, strlen(object->in.pwszServerName), "utf-8", "ignore");
   30749             :                 }
   30750             :         }
   30751           0 :         return py_pwszServerName;
   30752             : }
   30753             : 
   30754           0 : static int py_DnssrvUpdateRecord_in_set_pwszServerName(PyObject *py_obj, PyObject *value, void *closure)
   30755             : {
   30756           0 :         struct DnssrvUpdateRecord *object = pytalloc_get_ptr(py_obj);
   30757           0 :         if (value == NULL) {
   30758           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pwszServerName");
   30759           0 :                 return -1;
   30760             :         }
   30761           0 :         if (value == Py_None) {
   30762           0 :                 object->in.pwszServerName = NULL;
   30763             :         } else {
   30764           0 :                 object->in.pwszServerName = NULL;
   30765             :                 {
   30766           0 :                         const char *test_str;
   30767           0 :                         const char *talloc_str;
   30768           0 :                         PyObject *unicode = NULL;
   30769           0 :                         if (PyUnicode_Check(value)) {
   30770           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   30771           0 :                                 if (unicode == NULL) {
   30772           0 :                                         return -1;
   30773             :                                 }
   30774           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   30775           0 :                         } else if (PyBytes_Check(value)) {
   30776           0 :                                 test_str = PyBytes_AS_STRING(value);
   30777             :                         } else {
   30778           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   30779           0 :                                 return -1;
   30780             :                         }
   30781           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   30782           0 :                         if (unicode != NULL) {
   30783           0 :                                 Py_DECREF(unicode);
   30784             :                         }
   30785           0 :                         if (talloc_str == NULL) {
   30786           0 :                                 PyErr_NoMemory();
   30787           0 :                                 return -1;
   30788             :                         }
   30789           0 :                         object->in.pwszServerName = talloc_str;
   30790             :                 }
   30791             :         }
   30792           0 :         return 0;
   30793             : }
   30794             : 
   30795           0 : static PyObject *py_DnssrvUpdateRecord_in_get_pszZone(PyObject *obj, void *closure)
   30796             : {
   30797           0 :         struct DnssrvUpdateRecord *object = pytalloc_get_ptr(obj);
   30798           0 :         PyObject *py_pszZone;
   30799           0 :         if (object->in.pszZone == NULL) {
   30800           0 :                 Py_RETURN_NONE;
   30801             :         }
   30802           0 :         if (object->in.pszZone == NULL) {
   30803           0 :                 py_pszZone = Py_None;
   30804           0 :                 Py_INCREF(py_pszZone);
   30805             :         } else {
   30806           0 :                 if (object->in.pszZone == NULL) {
   30807           0 :                         py_pszZone = Py_None;
   30808           0 :                         Py_INCREF(py_pszZone);
   30809             :                 } else {
   30810           0 :                         py_pszZone = PyUnicode_Decode(object->in.pszZone, strlen(object->in.pszZone), "utf-8", "ignore");
   30811             :                 }
   30812             :         }
   30813           0 :         return py_pszZone;
   30814             : }
   30815             : 
   30816           0 : static int py_DnssrvUpdateRecord_in_set_pszZone(PyObject *py_obj, PyObject *value, void *closure)
   30817             : {
   30818           0 :         struct DnssrvUpdateRecord *object = pytalloc_get_ptr(py_obj);
   30819           0 :         if (value == NULL) {
   30820           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszZone");
   30821           0 :                 return -1;
   30822             :         }
   30823           0 :         if (value == Py_None) {
   30824           0 :                 object->in.pszZone = NULL;
   30825             :         } else {
   30826           0 :                 object->in.pszZone = NULL;
   30827             :                 {
   30828           0 :                         const char *test_str;
   30829           0 :                         const char *talloc_str;
   30830           0 :                         PyObject *unicode = NULL;
   30831           0 :                         if (PyUnicode_Check(value)) {
   30832           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   30833           0 :                                 if (unicode == NULL) {
   30834           0 :                                         return -1;
   30835             :                                 }
   30836           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   30837           0 :                         } else if (PyBytes_Check(value)) {
   30838           0 :                                 test_str = PyBytes_AS_STRING(value);
   30839             :                         } else {
   30840           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   30841           0 :                                 return -1;
   30842             :                         }
   30843           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   30844           0 :                         if (unicode != NULL) {
   30845           0 :                                 Py_DECREF(unicode);
   30846             :                         }
   30847           0 :                         if (talloc_str == NULL) {
   30848           0 :                                 PyErr_NoMemory();
   30849           0 :                                 return -1;
   30850             :                         }
   30851           0 :                         object->in.pszZone = talloc_str;
   30852             :                 }
   30853             :         }
   30854           0 :         return 0;
   30855             : }
   30856             : 
   30857           0 : static PyObject *py_DnssrvUpdateRecord_in_get_pszNodeName(PyObject *obj, void *closure)
   30858             : {
   30859           0 :         struct DnssrvUpdateRecord *object = pytalloc_get_ptr(obj);
   30860           0 :         PyObject *py_pszNodeName;
   30861           0 :         if (object->in.pszNodeName == NULL) {
   30862           0 :                 Py_RETURN_NONE;
   30863             :         }
   30864           0 :         if (object->in.pszNodeName == NULL) {
   30865           0 :                 py_pszNodeName = Py_None;
   30866           0 :                 Py_INCREF(py_pszNodeName);
   30867             :         } else {
   30868           0 :                 if (object->in.pszNodeName == NULL) {
   30869           0 :                         py_pszNodeName = Py_None;
   30870           0 :                         Py_INCREF(py_pszNodeName);
   30871             :                 } else {
   30872           0 :                         py_pszNodeName = PyUnicode_Decode(object->in.pszNodeName, strlen(object->in.pszNodeName), "utf-8", "ignore");
   30873             :                 }
   30874             :         }
   30875           0 :         return py_pszNodeName;
   30876             : }
   30877             : 
   30878           0 : static int py_DnssrvUpdateRecord_in_set_pszNodeName(PyObject *py_obj, PyObject *value, void *closure)
   30879             : {
   30880           0 :         struct DnssrvUpdateRecord *object = pytalloc_get_ptr(py_obj);
   30881           0 :         if (value == NULL) {
   30882           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszNodeName");
   30883           0 :                 return -1;
   30884             :         }
   30885           0 :         if (value == Py_None) {
   30886           0 :                 object->in.pszNodeName = NULL;
   30887             :         } else {
   30888           0 :                 object->in.pszNodeName = NULL;
   30889             :                 {
   30890           0 :                         const char *test_str;
   30891           0 :                         const char *talloc_str;
   30892           0 :                         PyObject *unicode = NULL;
   30893           0 :                         if (PyUnicode_Check(value)) {
   30894           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   30895           0 :                                 if (unicode == NULL) {
   30896           0 :                                         return -1;
   30897             :                                 }
   30898           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   30899           0 :                         } else if (PyBytes_Check(value)) {
   30900           0 :                                 test_str = PyBytes_AS_STRING(value);
   30901             :                         } else {
   30902           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   30903           0 :                                 return -1;
   30904             :                         }
   30905           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   30906           0 :                         if (unicode != NULL) {
   30907           0 :                                 Py_DECREF(unicode);
   30908             :                         }
   30909           0 :                         if (talloc_str == NULL) {
   30910           0 :                                 PyErr_NoMemory();
   30911           0 :                                 return -1;
   30912             :                         }
   30913           0 :                         object->in.pszNodeName = talloc_str;
   30914             :                 }
   30915             :         }
   30916           0 :         return 0;
   30917             : }
   30918             : 
   30919           0 : static PyObject *py_DnssrvUpdateRecord_in_get_pAddRecord(PyObject *obj, void *closure)
   30920             : {
   30921           0 :         struct DnssrvUpdateRecord *object = pytalloc_get_ptr(obj);
   30922           0 :         PyObject *py_pAddRecord;
   30923           0 :         if (object->in.pAddRecord == NULL) {
   30924           0 :                 Py_RETURN_NONE;
   30925             :         }
   30926           0 :         if (object->in.pAddRecord == NULL) {
   30927           0 :                 py_pAddRecord = Py_None;
   30928           0 :                 Py_INCREF(py_pAddRecord);
   30929             :         } else {
   30930           0 :                 py_pAddRecord = pytalloc_reference_ex(&DNS_RPC_RECORD_BUF_Type, object->in.pAddRecord, object->in.pAddRecord);
   30931             :         }
   30932           0 :         return py_pAddRecord;
   30933             : }
   30934             : 
   30935           0 : static int py_DnssrvUpdateRecord_in_set_pAddRecord(PyObject *py_obj, PyObject *value, void *closure)
   30936             : {
   30937           0 :         struct DnssrvUpdateRecord *object = pytalloc_get_ptr(py_obj);
   30938           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.pAddRecord));
   30939           0 :         if (value == NULL) {
   30940           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pAddRecord");
   30941           0 :                 return -1;
   30942             :         }
   30943           0 :         if (value == Py_None) {
   30944           0 :                 object->in.pAddRecord = NULL;
   30945             :         } else {
   30946           0 :                 object->in.pAddRecord = NULL;
   30947           0 :                 PY_CHECK_TYPE(&DNS_RPC_RECORD_BUF_Type, value, return -1;);
   30948           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   30949           0 :                         PyErr_NoMemory();
   30950           0 :                         return -1;
   30951             :                 }
   30952           0 :                 object->in.pAddRecord = (struct DNS_RPC_RECORD_BUF *)pytalloc_get_ptr(value);
   30953             :         }
   30954           0 :         return 0;
   30955             : }
   30956             : 
   30957           0 : static PyObject *py_DnssrvUpdateRecord_in_get_pDeleteRecord(PyObject *obj, void *closure)
   30958             : {
   30959           0 :         struct DnssrvUpdateRecord *object = pytalloc_get_ptr(obj);
   30960           0 :         PyObject *py_pDeleteRecord;
   30961           0 :         if (object->in.pDeleteRecord == NULL) {
   30962           0 :                 Py_RETURN_NONE;
   30963             :         }
   30964           0 :         if (object->in.pDeleteRecord == NULL) {
   30965           0 :                 py_pDeleteRecord = Py_None;
   30966           0 :                 Py_INCREF(py_pDeleteRecord);
   30967             :         } else {
   30968           0 :                 py_pDeleteRecord = pytalloc_reference_ex(&DNS_RPC_RECORD_BUF_Type, object->in.pDeleteRecord, object->in.pDeleteRecord);
   30969             :         }
   30970           0 :         return py_pDeleteRecord;
   30971             : }
   30972             : 
   30973           0 : static int py_DnssrvUpdateRecord_in_set_pDeleteRecord(PyObject *py_obj, PyObject *value, void *closure)
   30974             : {
   30975           0 :         struct DnssrvUpdateRecord *object = pytalloc_get_ptr(py_obj);
   30976           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.pDeleteRecord));
   30977           0 :         if (value == NULL) {
   30978           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pDeleteRecord");
   30979           0 :                 return -1;
   30980             :         }
   30981           0 :         if (value == Py_None) {
   30982           0 :                 object->in.pDeleteRecord = NULL;
   30983             :         } else {
   30984           0 :                 object->in.pDeleteRecord = NULL;
   30985           0 :                 PY_CHECK_TYPE(&DNS_RPC_RECORD_BUF_Type, value, return -1;);
   30986           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   30987           0 :                         PyErr_NoMemory();
   30988           0 :                         return -1;
   30989             :                 }
   30990           0 :                 object->in.pDeleteRecord = (struct DNS_RPC_RECORD_BUF *)pytalloc_get_ptr(value);
   30991             :         }
   30992           0 :         return 0;
   30993             : }
   30994             : 
   30995           0 : static PyObject *py_DnssrvUpdateRecord_get_result(PyObject *obj, void *closure)
   30996             : {
   30997           0 :         struct DnssrvUpdateRecord *object = pytalloc_get_ptr(obj);
   30998           0 :         PyObject *py_result;
   30999           0 :         py_result = PyErr_FromWERROR(object->out.result);
   31000           0 :         return py_result;
   31001             : }
   31002             : 
   31003           0 : static int py_DnssrvUpdateRecord_set_result(PyObject *py_obj, PyObject *value, void *closure)
   31004             : {
   31005           0 :         struct DnssrvUpdateRecord *object = pytalloc_get_ptr(py_obj);
   31006           0 :         if (value == NULL) {
   31007           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.result");
   31008           0 :                 return -1;
   31009             :         }
   31010           0 :         object->out.result = W_ERROR(PyLong_AsLong(value));
   31011           0 :         return 0;
   31012             : }
   31013             : 
   31014             : static PyGetSetDef py_DnssrvUpdateRecord_getsetters[] = {
   31015             :         {
   31016             :                 .name = discard_const_p(char, "in_pwszServerName"),
   31017             :                 .get = py_DnssrvUpdateRecord_in_get_pwszServerName,
   31018             :                 .set = py_DnssrvUpdateRecord_in_set_pwszServerName,
   31019             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
   31020             :         },
   31021             :         {
   31022             :                 .name = discard_const_p(char, "in_pszZone"),
   31023             :                 .get = py_DnssrvUpdateRecord_in_get_pszZone,
   31024             :                 .set = py_DnssrvUpdateRecord_in_set_pszZone,
   31025             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   31026             :         },
   31027             :         {
   31028             :                 .name = discard_const_p(char, "in_pszNodeName"),
   31029             :                 .get = py_DnssrvUpdateRecord_in_get_pszNodeName,
   31030             :                 .set = py_DnssrvUpdateRecord_in_set_pszNodeName,
   31031             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   31032             :         },
   31033             :         {
   31034             :                 .name = discard_const_p(char, "in_pAddRecord"),
   31035             :                 .get = py_DnssrvUpdateRecord_in_get_pAddRecord,
   31036             :                 .set = py_DnssrvUpdateRecord_in_set_pAddRecord,
   31037             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_RECORD_BUF")
   31038             :         },
   31039             :         {
   31040             :                 .name = discard_const_p(char, "in_pDeleteRecord"),
   31041             :                 .get = py_DnssrvUpdateRecord_in_get_pDeleteRecord,
   31042             :                 .set = py_DnssrvUpdateRecord_in_set_pDeleteRecord,
   31043             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_RECORD_BUF")
   31044             :         },
   31045             :         {
   31046             :                 .name = discard_const_p(char, "result"),
   31047             :                 .get = py_DnssrvUpdateRecord_get_result,
   31048             :                 .set = py_DnssrvUpdateRecord_set_result,
   31049             :                 .doc = discard_const_p(char, "PIDL-generated element of type WERROR")
   31050             :         },
   31051             :         { .name = NULL }
   31052             : };
   31053             : 
   31054           0 : static PyObject *py_DnssrvUpdateRecord_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   31055             : {
   31056           0 :         PyObject *self = pytalloc_new(struct DnssrvUpdateRecord, type);
   31057           0 :         return self;
   31058             : }
   31059             : 
   31060           0 : static PyObject *py_DnssrvUpdateRecord_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
   31061             : {
   31062             : 
   31063             : 
   31064           0 :         return PyLong_FromLong(4);
   31065             : }
   31066             : 
   31067           0 : static PyObject *py_DnssrvUpdateRecord_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
   31068             : {
   31069           0 :         const struct ndr_interface_call *call = NULL;
   31070           0 :         struct DnssrvUpdateRecord *object = pytalloc_get_ptr(py_obj);
   31071           0 :         PyObject *ret = NULL;
   31072           0 :         struct ndr_push *push = NULL;
   31073           0 :         DATA_BLOB blob;
   31074           0 :         enum ndr_err_code err;
   31075             : 
   31076           0 :         if (ndr_table_dnsserver.num_calls < 5) {
   31077           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvUpdateRecord_ndr_pack");
   31078           0 :                 return NULL;
   31079             :         }
   31080           0 :         call = &ndr_table_dnsserver.calls[4];
   31081             : 
   31082           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
   31083           0 :         if (push == NULL) {
   31084           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
   31085           0 :                 return NULL;
   31086             :         }
   31087             : 
   31088           0 :         push->flags |= ndr_push_flags;
   31089             : 
   31090           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
   31091           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   31092           0 :                 TALLOC_FREE(push);
   31093           0 :                 PyErr_SetNdrError(err);
   31094           0 :                 return NULL;
   31095             :         }
   31096           0 :         blob = ndr_push_blob(push);
   31097           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
   31098           0 :         TALLOC_FREE(push);
   31099           0 :         return ret;
   31100             : }
   31101             : 
   31102           0 : static PyObject *py_DnssrvUpdateRecord_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   31103             : {
   31104           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
   31105           0 :         PyObject *bigendian_obj = NULL;
   31106           0 :         PyObject *ndr64_obj = NULL;
   31107           0 :         libndr_flags ndr_push_flags = 0;
   31108             : 
   31109           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
   31110             :                 discard_const_p(char *, kwnames),
   31111             :                 &bigendian_obj,
   31112             :                 &ndr64_obj)) {
   31113           0 :                 return NULL;
   31114             :         }
   31115             : 
   31116           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   31117           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
   31118             :         }
   31119           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   31120           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
   31121             :         }
   31122             : 
   31123           0 :         return py_DnssrvUpdateRecord_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
   31124             : }
   31125             : 
   31126           0 : static PyObject *py_DnssrvUpdateRecord_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   31127             : {
   31128           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
   31129           0 :         PyObject *bigendian_obj = NULL;
   31130           0 :         PyObject *ndr64_obj = NULL;
   31131           0 :         libndr_flags ndr_push_flags = 0;
   31132             : 
   31133           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
   31134             :                 discard_const_p(char *, kwnames),
   31135             :                 &bigendian_obj,
   31136             :                 &ndr64_obj)) {
   31137           0 :                 return NULL;
   31138             :         }
   31139             : 
   31140           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   31141           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
   31142             :         }
   31143           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   31144           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
   31145             :         }
   31146             : 
   31147           0 :         return py_DnssrvUpdateRecord_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
   31148             : }
   31149             : 
   31150           0 : static PyObject *py_DnssrvUpdateRecord_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
   31151             : {
   31152           0 :         const struct ndr_interface_call *call = NULL;
   31153           0 :         struct DnssrvUpdateRecord *object = pytalloc_get_ptr(py_obj);
   31154           0 :         struct ndr_pull *pull = NULL;
   31155           0 :         enum ndr_err_code err;
   31156             : 
   31157           0 :         if (ndr_table_dnsserver.num_calls < 5) {
   31158           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvUpdateRecord_ndr_unpack");
   31159           0 :                 return NULL;
   31160             :         }
   31161           0 :         call = &ndr_table_dnsserver.calls[4];
   31162             : 
   31163           0 :         pull = ndr_pull_init_blob(blob, object);
   31164           0 :         if (pull == NULL) {
   31165           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
   31166           0 :                 return NULL;
   31167             :         }
   31168             : 
   31169           0 :         pull->flags |= ndr_pull_flags;
   31170             : 
   31171           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
   31172           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   31173           0 :                 TALLOC_FREE(pull);
   31174           0 :                 PyErr_SetNdrError(err);
   31175           0 :                 return NULL;
   31176             :         }
   31177           0 :         if (!allow_remaining) {
   31178           0 :                 uint32_t highest_ofs;
   31179             : 
   31180           0 :                 if (pull->offset > pull->relative_highest_offset) {
   31181           0 :                         highest_ofs = pull->offset;
   31182             :                 } else {
   31183           0 :                         highest_ofs = pull->relative_highest_offset;
   31184             :                 }
   31185           0 :                 if (highest_ofs < pull->data_size) {
   31186           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
   31187             :                                 "not all bytes consumed ofs[%u] size[%u]",
   31188             :                                 highest_ofs, pull->data_size);
   31189           0 :                         TALLOC_FREE(pull);
   31190           0 :                         PyErr_SetNdrError(err);
   31191           0 :                         return NULL;
   31192             :                 }
   31193             :         }
   31194             : 
   31195           0 :         TALLOC_FREE(pull);
   31196           0 :         Py_RETURN_NONE;
   31197             : }
   31198             : 
   31199           0 : static PyObject *py_DnssrvUpdateRecord_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   31200             : {
   31201           0 :         DATA_BLOB blob;
   31202           0 :         Py_ssize_t blob_length = 0;
   31203           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
   31204           0 :         PyObject *bigendian_obj = NULL;
   31205           0 :         PyObject *ndr64_obj = NULL;
   31206           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
   31207           0 :         PyObject *allow_remaining_obj = NULL;
   31208           0 :         bool allow_remaining = false;
   31209             : 
   31210           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
   31211             :                 discard_const_p(char *, kwnames),
   31212             :                 &blob.data, &blob_length,
   31213             :                 &bigendian_obj,
   31214             :                 &ndr64_obj,
   31215             :                 &allow_remaining_obj)) {
   31216           0 :                 return NULL;
   31217             :         }
   31218           0 :         blob.length = blob_length;
   31219             : 
   31220           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   31221           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
   31222             :         }
   31223           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   31224           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
   31225             :         }
   31226             : 
   31227           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
   31228           0 :                 allow_remaining = true;
   31229             :         }
   31230             : 
   31231           0 :         return py_DnssrvUpdateRecord_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
   31232             : }
   31233             : 
   31234           0 : static PyObject *py_DnssrvUpdateRecord_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   31235             : {
   31236           0 :         DATA_BLOB blob;
   31237           0 :         Py_ssize_t blob_length = 0;
   31238           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
   31239           0 :         PyObject *bigendian_obj = NULL;
   31240           0 :         PyObject *ndr64_obj = NULL;
   31241           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
   31242           0 :         PyObject *allow_remaining_obj = NULL;
   31243           0 :         bool allow_remaining = false;
   31244             : 
   31245           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
   31246             :                 discard_const_p(char *, kwnames),
   31247             :                 &blob.data, &blob_length,
   31248             :                 &bigendian_obj,
   31249             :                 &ndr64_obj,
   31250             :                 &allow_remaining_obj)) {
   31251           0 :                 return NULL;
   31252             :         }
   31253           0 :         blob.length = blob_length;
   31254             : 
   31255           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   31256           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
   31257             :         }
   31258           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   31259           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
   31260             :         }
   31261             : 
   31262           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
   31263           0 :                 allow_remaining = true;
   31264             :         }
   31265             : 
   31266           0 :         return py_DnssrvUpdateRecord_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
   31267             : }
   31268             : 
   31269           0 : static PyObject *py_DnssrvUpdateRecord_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
   31270             : {
   31271           0 :         const struct ndr_interface_call *call = NULL;
   31272           0 :         struct DnssrvUpdateRecord *object = pytalloc_get_ptr(py_obj);
   31273           0 :         PyObject *ret;
   31274           0 :         char *retstr;
   31275             : 
   31276           0 :         if (ndr_table_dnsserver.num_calls < 5) {
   31277           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvUpdateRecord_ndr_print");
   31278           0 :                 return NULL;
   31279             :         }
   31280           0 :         call = &ndr_table_dnsserver.calls[4];
   31281             : 
   31282           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
   31283           0 :         ret = PyUnicode_FromString(retstr);
   31284           0 :         TALLOC_FREE(retstr);
   31285             : 
   31286           0 :         return ret;
   31287             : }
   31288             : 
   31289           0 : static PyObject *py_DnssrvUpdateRecord_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
   31290             : {
   31291           0 :         return py_DnssrvUpdateRecord_ndr_print(py_obj, "DnssrvUpdateRecord_in", NDR_IN);
   31292             : }
   31293             : 
   31294           0 : static PyObject *py_DnssrvUpdateRecord_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
   31295             : {
   31296           0 :         return py_DnssrvUpdateRecord_ndr_print(py_obj, "DnssrvUpdateRecord_out", NDR_OUT);
   31297             : }
   31298             : 
   31299             : static PyMethodDef py_DnssrvUpdateRecord_methods[] = {
   31300             :         { "opnum", (PyCFunction)py_DnssrvUpdateRecord_ndr_opnum, METH_NOARGS|METH_CLASS,
   31301             :                 "dnsserver.DnssrvUpdateRecord.opnum() -> 4 (0x04) " },
   31302             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvUpdateRecord_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
   31303             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
   31304             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvUpdateRecord_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
   31305             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
   31306             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvUpdateRecord_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
   31307             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
   31308             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvUpdateRecord_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
   31309             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
   31310             :         { "__ndr_print_in__", (PyCFunction)py_DnssrvUpdateRecord_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
   31311             :         { "__ndr_print_out__", (PyCFunction)py_DnssrvUpdateRecord_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
   31312             :         { NULL, NULL, 0, NULL }
   31313             : };
   31314             : 
   31315             : 
   31316             : static PyTypeObject DnssrvUpdateRecord_Type = {
   31317             :         PyVarObject_HEAD_INIT(NULL, 0)
   31318             :         .tp_name = "dnsserver.DnssrvUpdateRecord",
   31319             :         .tp_getset = py_DnssrvUpdateRecord_getsetters,
   31320             :         .tp_methods = py_DnssrvUpdateRecord_methods,
   31321             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   31322             :         .tp_new = py_DnssrvUpdateRecord_new,
   31323             : };
   31324             : 
   31325           0 : static bool pack_py_DnssrvUpdateRecord_args_in(PyObject *args, PyObject *kwargs, struct DnssrvUpdateRecord *r)
   31326             : {
   31327           0 :         PyObject *py_pwszServerName;
   31328           0 :         PyObject *py_pszZone;
   31329           0 :         PyObject *py_pszNodeName;
   31330           0 :         PyObject *py_pAddRecord;
   31331           0 :         PyObject *py_pDeleteRecord;
   31332           0 :         const char *kwnames[] = {
   31333             :                 "pwszServerName", "pszZone", "pszNodeName", "pAddRecord", "pDeleteRecord", NULL
   31334             :         };
   31335             : 
   31336           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:DnssrvUpdateRecord", discard_const_p(char *, kwnames), &py_pwszServerName, &py_pszZone, &py_pszNodeName, &py_pAddRecord, &py_pDeleteRecord)) {
   31337           0 :                 return false;
   31338             :         }
   31339             : 
   31340           0 :         if (py_pwszServerName == NULL) {
   31341           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pwszServerName");
   31342           0 :                 return false;
   31343             :         }
   31344           0 :         if (py_pwszServerName == Py_None) {
   31345           0 :                 r->in.pwszServerName = NULL;
   31346             :         } else {
   31347           0 :                 r->in.pwszServerName = NULL;
   31348             :                 {
   31349           0 :                         const char *test_str;
   31350           0 :                         const char *talloc_str;
   31351           0 :                         PyObject *unicode = NULL;
   31352           0 :                         if (PyUnicode_Check(py_pwszServerName)) {
   31353           0 :                                 unicode = PyUnicode_AsEncodedString(py_pwszServerName, "utf-8", "ignore");
   31354           0 :                                 if (unicode == NULL) {
   31355           0 :                                         return false;
   31356             :                                 }
   31357           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   31358           0 :                         } else if (PyBytes_Check(py_pwszServerName)) {
   31359           0 :                                 test_str = PyBytes_AS_STRING(py_pwszServerName);
   31360             :                         } else {
   31361           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pwszServerName)->tp_name);
   31362           0 :                                 return false;
   31363             :                         }
   31364           0 :                         talloc_str = talloc_strdup(r, test_str);
   31365           0 :                         if (unicode != NULL) {
   31366           0 :                                 Py_DECREF(unicode);
   31367             :                         }
   31368           0 :                         if (talloc_str == NULL) {
   31369           0 :                                 PyErr_NoMemory();
   31370           0 :                                 return false;
   31371             :                         }
   31372           0 :                         r->in.pwszServerName = talloc_str;
   31373             :                 }
   31374             :         }
   31375           0 :         if (py_pszZone == NULL) {
   31376           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszZone");
   31377           0 :                 return false;
   31378             :         }
   31379           0 :         if (py_pszZone == Py_None) {
   31380           0 :                 r->in.pszZone = NULL;
   31381             :         } else {
   31382           0 :                 r->in.pszZone = NULL;
   31383             :                 {
   31384           0 :                         const char *test_str;
   31385           0 :                         const char *talloc_str;
   31386           0 :                         PyObject *unicode = NULL;
   31387           0 :                         if (PyUnicode_Check(py_pszZone)) {
   31388           0 :                                 unicode = PyUnicode_AsEncodedString(py_pszZone, "utf-8", "ignore");
   31389           0 :                                 if (unicode == NULL) {
   31390           0 :                                         return false;
   31391             :                                 }
   31392           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   31393           0 :                         } else if (PyBytes_Check(py_pszZone)) {
   31394           0 :                                 test_str = PyBytes_AS_STRING(py_pszZone);
   31395             :                         } else {
   31396           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszZone)->tp_name);
   31397           0 :                                 return false;
   31398             :                         }
   31399           0 :                         talloc_str = talloc_strdup(r, test_str);
   31400           0 :                         if (unicode != NULL) {
   31401           0 :                                 Py_DECREF(unicode);
   31402             :                         }
   31403           0 :                         if (talloc_str == NULL) {
   31404           0 :                                 PyErr_NoMemory();
   31405           0 :                                 return false;
   31406             :                         }
   31407           0 :                         r->in.pszZone = talloc_str;
   31408             :                 }
   31409             :         }
   31410           0 :         if (py_pszNodeName == NULL) {
   31411           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszNodeName");
   31412           0 :                 return false;
   31413             :         }
   31414           0 :         if (py_pszNodeName == Py_None) {
   31415           0 :                 r->in.pszNodeName = NULL;
   31416             :         } else {
   31417           0 :                 r->in.pszNodeName = NULL;
   31418             :                 {
   31419           0 :                         const char *test_str;
   31420           0 :                         const char *talloc_str;
   31421           0 :                         PyObject *unicode = NULL;
   31422           0 :                         if (PyUnicode_Check(py_pszNodeName)) {
   31423           0 :                                 unicode = PyUnicode_AsEncodedString(py_pszNodeName, "utf-8", "ignore");
   31424           0 :                                 if (unicode == NULL) {
   31425           0 :                                         return false;
   31426             :                                 }
   31427           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   31428           0 :                         } else if (PyBytes_Check(py_pszNodeName)) {
   31429           0 :                                 test_str = PyBytes_AS_STRING(py_pszNodeName);
   31430             :                         } else {
   31431           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszNodeName)->tp_name);
   31432           0 :                                 return false;
   31433             :                         }
   31434           0 :                         talloc_str = talloc_strdup(r, test_str);
   31435           0 :                         if (unicode != NULL) {
   31436           0 :                                 Py_DECREF(unicode);
   31437             :                         }
   31438           0 :                         if (talloc_str == NULL) {
   31439           0 :                                 PyErr_NoMemory();
   31440           0 :                                 return false;
   31441             :                         }
   31442           0 :                         r->in.pszNodeName = talloc_str;
   31443             :                 }
   31444             :         }
   31445           0 :         if (py_pAddRecord == NULL) {
   31446           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pAddRecord");
   31447           0 :                 return false;
   31448             :         }
   31449           0 :         if (py_pAddRecord == Py_None) {
   31450           0 :                 r->in.pAddRecord = NULL;
   31451             :         } else {
   31452           0 :                 r->in.pAddRecord = NULL;
   31453           0 :                 PY_CHECK_TYPE(&DNS_RPC_RECORD_BUF_Type, py_pAddRecord, return false;);
   31454           0 :                 if (talloc_reference(r, pytalloc_get_mem_ctx(py_pAddRecord)) == NULL) {
   31455           0 :                         PyErr_NoMemory();
   31456           0 :                         return false;
   31457             :                 }
   31458           0 :                 r->in.pAddRecord = (struct DNS_RPC_RECORD_BUF *)pytalloc_get_ptr(py_pAddRecord);
   31459             :         }
   31460           0 :         if (py_pDeleteRecord == NULL) {
   31461           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pDeleteRecord");
   31462           0 :                 return false;
   31463             :         }
   31464           0 :         if (py_pDeleteRecord == Py_None) {
   31465           0 :                 r->in.pDeleteRecord = NULL;
   31466             :         } else {
   31467           0 :                 r->in.pDeleteRecord = NULL;
   31468           0 :                 PY_CHECK_TYPE(&DNS_RPC_RECORD_BUF_Type, py_pDeleteRecord, return false;);
   31469           0 :                 if (talloc_reference(r, pytalloc_get_mem_ctx(py_pDeleteRecord)) == NULL) {
   31470           0 :                         PyErr_NoMemory();
   31471           0 :                         return false;
   31472             :                 }
   31473           0 :                 r->in.pDeleteRecord = (struct DNS_RPC_RECORD_BUF *)pytalloc_get_ptr(py_pDeleteRecord);
   31474             :         }
   31475           0 :         return true;
   31476             : }
   31477             : 
   31478           0 : static PyObject *unpack_py_DnssrvUpdateRecord_args_out(struct DnssrvUpdateRecord *r)
   31479             : {
   31480           0 :         PyObject *result;
   31481           0 :         result = Py_None;
   31482           0 :         Py_INCREF(result);
   31483           0 :         if (!W_ERROR_IS_OK(r->out.result)) {
   31484           0 :                 PyErr_SetWERROR(r->out.result);
   31485           0 :                 return NULL;
   31486             :         }
   31487             : 
   31488           0 :         return result;
   31489             : }
   31490             : 
   31491             : 
   31492           0 : static PyObject *py_DnssrvOperation2_in_get_dwClientVersion(PyObject *obj, void *closure)
   31493             : {
   31494           0 :         struct DnssrvOperation2 *object = pytalloc_get_ptr(obj);
   31495           0 :         PyObject *py_dwClientVersion;
   31496           0 :         py_dwClientVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->in.dwClientVersion));
   31497           0 :         return py_dwClientVersion;
   31498             : }
   31499             : 
   31500           0 : static int py_DnssrvOperation2_in_set_dwClientVersion(PyObject *py_obj, PyObject *value, void *closure)
   31501             : {
   31502           0 :         struct DnssrvOperation2 *object = pytalloc_get_ptr(py_obj);
   31503           0 :         if (value == NULL) {
   31504           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.dwClientVersion");
   31505           0 :                 return -1;
   31506             :         }
   31507             :         {
   31508           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.dwClientVersion));
   31509           0 :                 if (PyLong_Check(value)) {
   31510           0 :                         unsigned long long test_var;
   31511           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   31512           0 :                         if (PyErr_Occurred() != NULL) {
   31513           0 :                                 return -1;
   31514             :                         }
   31515           0 :                         if (test_var > uint_max) {
   31516           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   31517             :                                   PyLong_Type.tp_name, uint_max, test_var);
   31518           0 :                                 return -1;
   31519             :                         }
   31520           0 :                         object->in.dwClientVersion = test_var;
   31521             :                 } else {
   31522           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   31523             :                           PyLong_Type.tp_name);
   31524           0 :                         return -1;
   31525             :                 }
   31526             :         }
   31527           0 :         return 0;
   31528             : }
   31529             : 
   31530           0 : static PyObject *py_DnssrvOperation2_in_get_dwSettingFlags(PyObject *obj, void *closure)
   31531             : {
   31532           0 :         struct DnssrvOperation2 *object = pytalloc_get_ptr(obj);
   31533           0 :         PyObject *py_dwSettingFlags;
   31534           0 :         py_dwSettingFlags = PyLong_FromUnsignedLongLong((uint32_t)(object->in.dwSettingFlags));
   31535           0 :         return py_dwSettingFlags;
   31536             : }
   31537             : 
   31538           0 : static int py_DnssrvOperation2_in_set_dwSettingFlags(PyObject *py_obj, PyObject *value, void *closure)
   31539             : {
   31540           0 :         struct DnssrvOperation2 *object = pytalloc_get_ptr(py_obj);
   31541           0 :         if (value == NULL) {
   31542           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.dwSettingFlags");
   31543           0 :                 return -1;
   31544             :         }
   31545             :         {
   31546           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.dwSettingFlags));
   31547           0 :                 if (PyLong_Check(value)) {
   31548           0 :                         unsigned long long test_var;
   31549           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   31550           0 :                         if (PyErr_Occurred() != NULL) {
   31551           0 :                                 return -1;
   31552             :                         }
   31553           0 :                         if (test_var > uint_max) {
   31554           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   31555             :                                   PyLong_Type.tp_name, uint_max, test_var);
   31556           0 :                                 return -1;
   31557             :                         }
   31558           0 :                         object->in.dwSettingFlags = test_var;
   31559             :                 } else {
   31560           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   31561             :                           PyLong_Type.tp_name);
   31562           0 :                         return -1;
   31563             :                 }
   31564             :         }
   31565           0 :         return 0;
   31566             : }
   31567             : 
   31568           0 : static PyObject *py_DnssrvOperation2_in_get_pwszServerName(PyObject *obj, void *closure)
   31569             : {
   31570           0 :         struct DnssrvOperation2 *object = pytalloc_get_ptr(obj);
   31571           0 :         PyObject *py_pwszServerName;
   31572           0 :         if (object->in.pwszServerName == NULL) {
   31573           0 :                 Py_RETURN_NONE;
   31574             :         }
   31575           0 :         if (object->in.pwszServerName == NULL) {
   31576           0 :                 py_pwszServerName = Py_None;
   31577           0 :                 Py_INCREF(py_pwszServerName);
   31578             :         } else {
   31579           0 :                 if (object->in.pwszServerName == NULL) {
   31580           0 :                         py_pwszServerName = Py_None;
   31581           0 :                         Py_INCREF(py_pwszServerName);
   31582             :                 } else {
   31583           0 :                         py_pwszServerName = PyUnicode_Decode(object->in.pwszServerName, strlen(object->in.pwszServerName), "utf-8", "ignore");
   31584             :                 }
   31585             :         }
   31586           0 :         return py_pwszServerName;
   31587             : }
   31588             : 
   31589           0 : static int py_DnssrvOperation2_in_set_pwszServerName(PyObject *py_obj, PyObject *value, void *closure)
   31590             : {
   31591           0 :         struct DnssrvOperation2 *object = pytalloc_get_ptr(py_obj);
   31592           0 :         if (value == NULL) {
   31593           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pwszServerName");
   31594           0 :                 return -1;
   31595             :         }
   31596           0 :         if (value == Py_None) {
   31597           0 :                 object->in.pwszServerName = NULL;
   31598             :         } else {
   31599           0 :                 object->in.pwszServerName = NULL;
   31600             :                 {
   31601           0 :                         const char *test_str;
   31602           0 :                         const char *talloc_str;
   31603           0 :                         PyObject *unicode = NULL;
   31604           0 :                         if (PyUnicode_Check(value)) {
   31605           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   31606           0 :                                 if (unicode == NULL) {
   31607           0 :                                         return -1;
   31608             :                                 }
   31609           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   31610           0 :                         } else if (PyBytes_Check(value)) {
   31611           0 :                                 test_str = PyBytes_AS_STRING(value);
   31612             :                         } else {
   31613           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   31614           0 :                                 return -1;
   31615             :                         }
   31616           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   31617           0 :                         if (unicode != NULL) {
   31618           0 :                                 Py_DECREF(unicode);
   31619             :                         }
   31620           0 :                         if (talloc_str == NULL) {
   31621           0 :                                 PyErr_NoMemory();
   31622           0 :                                 return -1;
   31623             :                         }
   31624           0 :                         object->in.pwszServerName = talloc_str;
   31625             :                 }
   31626             :         }
   31627           0 :         return 0;
   31628             : }
   31629             : 
   31630           0 : static PyObject *py_DnssrvOperation2_in_get_pszZone(PyObject *obj, void *closure)
   31631             : {
   31632           0 :         struct DnssrvOperation2 *object = pytalloc_get_ptr(obj);
   31633           0 :         PyObject *py_pszZone;
   31634           0 :         if (object->in.pszZone == NULL) {
   31635           0 :                 Py_RETURN_NONE;
   31636             :         }
   31637           0 :         if (object->in.pszZone == NULL) {
   31638           0 :                 py_pszZone = Py_None;
   31639           0 :                 Py_INCREF(py_pszZone);
   31640             :         } else {
   31641           0 :                 if (object->in.pszZone == NULL) {
   31642           0 :                         py_pszZone = Py_None;
   31643           0 :                         Py_INCREF(py_pszZone);
   31644             :                 } else {
   31645           0 :                         py_pszZone = PyUnicode_Decode(object->in.pszZone, strlen(object->in.pszZone), "utf-8", "ignore");
   31646             :                 }
   31647             :         }
   31648           0 :         return py_pszZone;
   31649             : }
   31650             : 
   31651           0 : static int py_DnssrvOperation2_in_set_pszZone(PyObject *py_obj, PyObject *value, void *closure)
   31652             : {
   31653           0 :         struct DnssrvOperation2 *object = pytalloc_get_ptr(py_obj);
   31654           0 :         if (value == NULL) {
   31655           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszZone");
   31656           0 :                 return -1;
   31657             :         }
   31658           0 :         if (value == Py_None) {
   31659           0 :                 object->in.pszZone = NULL;
   31660             :         } else {
   31661           0 :                 object->in.pszZone = NULL;
   31662             :                 {
   31663           0 :                         const char *test_str;
   31664           0 :                         const char *talloc_str;
   31665           0 :                         PyObject *unicode = NULL;
   31666           0 :                         if (PyUnicode_Check(value)) {
   31667           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   31668           0 :                                 if (unicode == NULL) {
   31669           0 :                                         return -1;
   31670             :                                 }
   31671           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   31672           0 :                         } else if (PyBytes_Check(value)) {
   31673           0 :                                 test_str = PyBytes_AS_STRING(value);
   31674             :                         } else {
   31675           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   31676           0 :                                 return -1;
   31677             :                         }
   31678           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   31679           0 :                         if (unicode != NULL) {
   31680           0 :                                 Py_DECREF(unicode);
   31681             :                         }
   31682           0 :                         if (talloc_str == NULL) {
   31683           0 :                                 PyErr_NoMemory();
   31684           0 :                                 return -1;
   31685             :                         }
   31686           0 :                         object->in.pszZone = talloc_str;
   31687             :                 }
   31688             :         }
   31689           0 :         return 0;
   31690             : }
   31691             : 
   31692           0 : static PyObject *py_DnssrvOperation2_in_get_dwContext(PyObject *obj, void *closure)
   31693             : {
   31694           0 :         struct DnssrvOperation2 *object = pytalloc_get_ptr(obj);
   31695           0 :         PyObject *py_dwContext;
   31696           0 :         py_dwContext = PyLong_FromUnsignedLongLong((uint32_t)(object->in.dwContext));
   31697           0 :         return py_dwContext;
   31698             : }
   31699             : 
   31700           0 : static int py_DnssrvOperation2_in_set_dwContext(PyObject *py_obj, PyObject *value, void *closure)
   31701             : {
   31702           0 :         struct DnssrvOperation2 *object = pytalloc_get_ptr(py_obj);
   31703           0 :         if (value == NULL) {
   31704           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.dwContext");
   31705           0 :                 return -1;
   31706             :         }
   31707             :         {
   31708           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.dwContext));
   31709           0 :                 if (PyLong_Check(value)) {
   31710           0 :                         unsigned long long test_var;
   31711           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   31712           0 :                         if (PyErr_Occurred() != NULL) {
   31713           0 :                                 return -1;
   31714             :                         }
   31715           0 :                         if (test_var > uint_max) {
   31716           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   31717             :                                   PyLong_Type.tp_name, uint_max, test_var);
   31718           0 :                                 return -1;
   31719             :                         }
   31720           0 :                         object->in.dwContext = test_var;
   31721             :                 } else {
   31722           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   31723             :                           PyLong_Type.tp_name);
   31724           0 :                         return -1;
   31725             :                 }
   31726             :         }
   31727           0 :         return 0;
   31728             : }
   31729             : 
   31730           0 : static PyObject *py_DnssrvOperation2_in_get_pszOperation(PyObject *obj, void *closure)
   31731             : {
   31732           0 :         struct DnssrvOperation2 *object = pytalloc_get_ptr(obj);
   31733           0 :         PyObject *py_pszOperation;
   31734           0 :         if (object->in.pszOperation == NULL) {
   31735           0 :                 Py_RETURN_NONE;
   31736             :         }
   31737           0 :         if (object->in.pszOperation == NULL) {
   31738           0 :                 py_pszOperation = Py_None;
   31739           0 :                 Py_INCREF(py_pszOperation);
   31740             :         } else {
   31741           0 :                 if (object->in.pszOperation == NULL) {
   31742           0 :                         py_pszOperation = Py_None;
   31743           0 :                         Py_INCREF(py_pszOperation);
   31744             :                 } else {
   31745           0 :                         py_pszOperation = PyUnicode_Decode(object->in.pszOperation, strlen(object->in.pszOperation), "utf-8", "ignore");
   31746             :                 }
   31747             :         }
   31748           0 :         return py_pszOperation;
   31749             : }
   31750             : 
   31751           0 : static int py_DnssrvOperation2_in_set_pszOperation(PyObject *py_obj, PyObject *value, void *closure)
   31752             : {
   31753           0 :         struct DnssrvOperation2 *object = pytalloc_get_ptr(py_obj);
   31754           0 :         if (value == NULL) {
   31755           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszOperation");
   31756           0 :                 return -1;
   31757             :         }
   31758           0 :         if (value == Py_None) {
   31759           0 :                 object->in.pszOperation = NULL;
   31760             :         } else {
   31761           0 :                 object->in.pszOperation = NULL;
   31762             :                 {
   31763           0 :                         const char *test_str;
   31764           0 :                         const char *talloc_str;
   31765           0 :                         PyObject *unicode = NULL;
   31766           0 :                         if (PyUnicode_Check(value)) {
   31767           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   31768           0 :                                 if (unicode == NULL) {
   31769           0 :                                         return -1;
   31770             :                                 }
   31771           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   31772           0 :                         } else if (PyBytes_Check(value)) {
   31773           0 :                                 test_str = PyBytes_AS_STRING(value);
   31774             :                         } else {
   31775           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   31776           0 :                                 return -1;
   31777             :                         }
   31778           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   31779           0 :                         if (unicode != NULL) {
   31780           0 :                                 Py_DECREF(unicode);
   31781             :                         }
   31782           0 :                         if (talloc_str == NULL) {
   31783           0 :                                 PyErr_NoMemory();
   31784           0 :                                 return -1;
   31785             :                         }
   31786           0 :                         object->in.pszOperation = talloc_str;
   31787             :                 }
   31788             :         }
   31789           0 :         return 0;
   31790             : }
   31791             : 
   31792           0 : static PyObject *py_DnssrvOperation2_in_get_dwTypeId(PyObject *obj, void *closure)
   31793             : {
   31794           0 :         struct DnssrvOperation2 *object = pytalloc_get_ptr(obj);
   31795           0 :         PyObject *py_dwTypeId;
   31796           0 :         py_dwTypeId = PyLong_FromUnsignedLongLong((uint32_t)(object->in.dwTypeId));
   31797           0 :         return py_dwTypeId;
   31798             : }
   31799             : 
   31800           0 : static int py_DnssrvOperation2_in_set_dwTypeId(PyObject *py_obj, PyObject *value, void *closure)
   31801             : {
   31802           0 :         struct DnssrvOperation2 *object = pytalloc_get_ptr(py_obj);
   31803           0 :         if (value == NULL) {
   31804           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.dwTypeId");
   31805           0 :                 return -1;
   31806             :         }
   31807             :         {
   31808           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.dwTypeId));
   31809           0 :                 if (PyLong_Check(value)) {
   31810           0 :                         unsigned long long test_var;
   31811           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   31812           0 :                         if (PyErr_Occurred() != NULL) {
   31813           0 :                                 return -1;
   31814             :                         }
   31815           0 :                         if (test_var > uint_max) {
   31816           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   31817             :                                   PyLong_Type.tp_name, uint_max, test_var);
   31818           0 :                                 return -1;
   31819             :                         }
   31820           0 :                         object->in.dwTypeId = test_var;
   31821             :                 } else {
   31822           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   31823             :                           PyLong_Type.tp_name);
   31824           0 :                         return -1;
   31825             :                 }
   31826             :         }
   31827           0 :         return 0;
   31828             : }
   31829             : 
   31830           0 : static PyObject *py_DnssrvOperation2_in_get_pData(PyObject *obj, void *closure)
   31831             : {
   31832           0 :         struct DnssrvOperation2 *object = pytalloc_get_ptr(obj);
   31833           0 :         PyObject *py_pData;
   31834           0 :         py_pData = pyrpc_import_union(&DNSSRV_RPC_UNION_Type, pytalloc_get_mem_ctx(obj), object->in.dwTypeId, &object->in.pData, "union DNSSRV_RPC_UNION");
   31835           0 :         if (py_pData == NULL) {
   31836           0 :                 return NULL;
   31837             :         }
   31838           0 :         return py_pData;
   31839             : }
   31840             : 
   31841           0 : static int py_DnssrvOperation2_in_set_pData(PyObject *py_obj, PyObject *value, void *closure)
   31842             : {
   31843           0 :         struct DnssrvOperation2 *object = pytalloc_get_ptr(py_obj);
   31844           0 :         if (value == NULL) {
   31845           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pData");
   31846           0 :                 return -1;
   31847             :         }
   31848             :         {
   31849           0 :                 union DNSSRV_RPC_UNION *pData_switch_0;
   31850           0 :                 pData_switch_0 = (union DNSSRV_RPC_UNION *)pyrpc_export_union(&DNSSRV_RPC_UNION_Type, pytalloc_get_mem_ctx(py_obj), object->in.dwTypeId, value, "union DNSSRV_RPC_UNION");
   31851           0 :                 if (pData_switch_0 == NULL) {
   31852           0 :                         return -1;
   31853             :                 }
   31854           0 :                 object->in.pData = *pData_switch_0;
   31855             :         }
   31856           0 :         return 0;
   31857             : }
   31858             : 
   31859           0 : static PyObject *py_DnssrvOperation2_get_result(PyObject *obj, void *closure)
   31860             : {
   31861           0 :         struct DnssrvOperation2 *object = pytalloc_get_ptr(obj);
   31862           0 :         PyObject *py_result;
   31863           0 :         py_result = PyErr_FromWERROR(object->out.result);
   31864           0 :         return py_result;
   31865             : }
   31866             : 
   31867           0 : static int py_DnssrvOperation2_set_result(PyObject *py_obj, PyObject *value, void *closure)
   31868             : {
   31869           0 :         struct DnssrvOperation2 *object = pytalloc_get_ptr(py_obj);
   31870           0 :         if (value == NULL) {
   31871           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.result");
   31872           0 :                 return -1;
   31873             :         }
   31874           0 :         object->out.result = W_ERROR(PyLong_AsLong(value));
   31875           0 :         return 0;
   31876             : }
   31877             : 
   31878             : static PyGetSetDef py_DnssrvOperation2_getsetters[] = {
   31879             :         {
   31880             :                 .name = discard_const_p(char, "in_dwClientVersion"),
   31881             :                 .get = py_DnssrvOperation2_in_get_dwClientVersion,
   31882             :                 .set = py_DnssrvOperation2_in_set_dwClientVersion,
   31883             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_CLIENT_VERSION")
   31884             :         },
   31885             :         {
   31886             :                 .name = discard_const_p(char, "in_dwSettingFlags"),
   31887             :                 .get = py_DnssrvOperation2_in_get_dwSettingFlags,
   31888             :                 .set = py_DnssrvOperation2_in_set_dwSettingFlags,
   31889             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   31890             :         },
   31891             :         {
   31892             :                 .name = discard_const_p(char, "in_pwszServerName"),
   31893             :                 .get = py_DnssrvOperation2_in_get_pwszServerName,
   31894             :                 .set = py_DnssrvOperation2_in_set_pwszServerName,
   31895             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
   31896             :         },
   31897             :         {
   31898             :                 .name = discard_const_p(char, "in_pszZone"),
   31899             :                 .get = py_DnssrvOperation2_in_get_pszZone,
   31900             :                 .set = py_DnssrvOperation2_in_set_pszZone,
   31901             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   31902             :         },
   31903             :         {
   31904             :                 .name = discard_const_p(char, "in_dwContext"),
   31905             :                 .get = py_DnssrvOperation2_in_get_dwContext,
   31906             :                 .set = py_DnssrvOperation2_in_set_dwContext,
   31907             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   31908             :         },
   31909             :         {
   31910             :                 .name = discard_const_p(char, "in_pszOperation"),
   31911             :                 .get = py_DnssrvOperation2_in_get_pszOperation,
   31912             :                 .set = py_DnssrvOperation2_in_set_pszOperation,
   31913             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   31914             :         },
   31915             :         {
   31916             :                 .name = discard_const_p(char, "in_dwTypeId"),
   31917             :                 .get = py_DnssrvOperation2_in_get_dwTypeId,
   31918             :                 .set = py_DnssrvOperation2_in_set_dwTypeId,
   31919             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_TYPEID")
   31920             :         },
   31921             :         {
   31922             :                 .name = discard_const_p(char, "in_pData"),
   31923             :                 .get = py_DnssrvOperation2_in_get_pData,
   31924             :                 .set = py_DnssrvOperation2_in_set_pData,
   31925             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNSSRV_RPC_UNION")
   31926             :         },
   31927             :         {
   31928             :                 .name = discard_const_p(char, "result"),
   31929             :                 .get = py_DnssrvOperation2_get_result,
   31930             :                 .set = py_DnssrvOperation2_set_result,
   31931             :                 .doc = discard_const_p(char, "PIDL-generated element of type WERROR")
   31932             :         },
   31933             :         { .name = NULL }
   31934             : };
   31935             : 
   31936           0 : static PyObject *py_DnssrvOperation2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   31937             : {
   31938           0 :         PyObject *self = pytalloc_new(struct DnssrvOperation2, type);
   31939           0 :         return self;
   31940             : }
   31941             : 
   31942           0 : static PyObject *py_DnssrvOperation2_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
   31943             : {
   31944             : 
   31945             : 
   31946           0 :         return PyLong_FromLong(5);
   31947             : }
   31948             : 
   31949           0 : static PyObject *py_DnssrvOperation2_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
   31950             : {
   31951           0 :         const struct ndr_interface_call *call = NULL;
   31952           0 :         struct DnssrvOperation2 *object = pytalloc_get_ptr(py_obj);
   31953           0 :         PyObject *ret = NULL;
   31954           0 :         struct ndr_push *push = NULL;
   31955           0 :         DATA_BLOB blob;
   31956           0 :         enum ndr_err_code err;
   31957             : 
   31958           0 :         if (ndr_table_dnsserver.num_calls < 6) {
   31959           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvOperation2_ndr_pack");
   31960           0 :                 return NULL;
   31961             :         }
   31962           0 :         call = &ndr_table_dnsserver.calls[5];
   31963             : 
   31964           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
   31965           0 :         if (push == NULL) {
   31966           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
   31967           0 :                 return NULL;
   31968             :         }
   31969             : 
   31970           0 :         push->flags |= ndr_push_flags;
   31971             : 
   31972           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
   31973           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   31974           0 :                 TALLOC_FREE(push);
   31975           0 :                 PyErr_SetNdrError(err);
   31976           0 :                 return NULL;
   31977             :         }
   31978           0 :         blob = ndr_push_blob(push);
   31979           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
   31980           0 :         TALLOC_FREE(push);
   31981           0 :         return ret;
   31982             : }
   31983             : 
   31984           0 : static PyObject *py_DnssrvOperation2_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   31985             : {
   31986           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
   31987           0 :         PyObject *bigendian_obj = NULL;
   31988           0 :         PyObject *ndr64_obj = NULL;
   31989           0 :         libndr_flags ndr_push_flags = 0;
   31990             : 
   31991           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
   31992             :                 discard_const_p(char *, kwnames),
   31993             :                 &bigendian_obj,
   31994             :                 &ndr64_obj)) {
   31995           0 :                 return NULL;
   31996             :         }
   31997             : 
   31998           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   31999           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
   32000             :         }
   32001           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   32002           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
   32003             :         }
   32004             : 
   32005           0 :         return py_DnssrvOperation2_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
   32006             : }
   32007             : 
   32008           0 : static PyObject *py_DnssrvOperation2_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   32009             : {
   32010           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
   32011           0 :         PyObject *bigendian_obj = NULL;
   32012           0 :         PyObject *ndr64_obj = NULL;
   32013           0 :         libndr_flags ndr_push_flags = 0;
   32014             : 
   32015           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
   32016             :                 discard_const_p(char *, kwnames),
   32017             :                 &bigendian_obj,
   32018             :                 &ndr64_obj)) {
   32019           0 :                 return NULL;
   32020             :         }
   32021             : 
   32022           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   32023           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
   32024             :         }
   32025           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   32026           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
   32027             :         }
   32028             : 
   32029           0 :         return py_DnssrvOperation2_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
   32030             : }
   32031             : 
   32032           0 : static PyObject *py_DnssrvOperation2_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
   32033             : {
   32034           0 :         const struct ndr_interface_call *call = NULL;
   32035           0 :         struct DnssrvOperation2 *object = pytalloc_get_ptr(py_obj);
   32036           0 :         struct ndr_pull *pull = NULL;
   32037           0 :         enum ndr_err_code err;
   32038             : 
   32039           0 :         if (ndr_table_dnsserver.num_calls < 6) {
   32040           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvOperation2_ndr_unpack");
   32041           0 :                 return NULL;
   32042             :         }
   32043           0 :         call = &ndr_table_dnsserver.calls[5];
   32044             : 
   32045           0 :         pull = ndr_pull_init_blob(blob, object);
   32046           0 :         if (pull == NULL) {
   32047           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
   32048           0 :                 return NULL;
   32049             :         }
   32050             : 
   32051           0 :         pull->flags |= ndr_pull_flags;
   32052             : 
   32053           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
   32054           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   32055           0 :                 TALLOC_FREE(pull);
   32056           0 :                 PyErr_SetNdrError(err);
   32057           0 :                 return NULL;
   32058             :         }
   32059           0 :         if (!allow_remaining) {
   32060           0 :                 uint32_t highest_ofs;
   32061             : 
   32062           0 :                 if (pull->offset > pull->relative_highest_offset) {
   32063           0 :                         highest_ofs = pull->offset;
   32064             :                 } else {
   32065           0 :                         highest_ofs = pull->relative_highest_offset;
   32066             :                 }
   32067           0 :                 if (highest_ofs < pull->data_size) {
   32068           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
   32069             :                                 "not all bytes consumed ofs[%u] size[%u]",
   32070             :                                 highest_ofs, pull->data_size);
   32071           0 :                         TALLOC_FREE(pull);
   32072           0 :                         PyErr_SetNdrError(err);
   32073           0 :                         return NULL;
   32074             :                 }
   32075             :         }
   32076             : 
   32077           0 :         TALLOC_FREE(pull);
   32078           0 :         Py_RETURN_NONE;
   32079             : }
   32080             : 
   32081           0 : static PyObject *py_DnssrvOperation2_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   32082             : {
   32083           0 :         DATA_BLOB blob;
   32084           0 :         Py_ssize_t blob_length = 0;
   32085           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
   32086           0 :         PyObject *bigendian_obj = NULL;
   32087           0 :         PyObject *ndr64_obj = NULL;
   32088           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
   32089           0 :         PyObject *allow_remaining_obj = NULL;
   32090           0 :         bool allow_remaining = false;
   32091             : 
   32092           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
   32093             :                 discard_const_p(char *, kwnames),
   32094             :                 &blob.data, &blob_length,
   32095             :                 &bigendian_obj,
   32096             :                 &ndr64_obj,
   32097             :                 &allow_remaining_obj)) {
   32098           0 :                 return NULL;
   32099             :         }
   32100           0 :         blob.length = blob_length;
   32101             : 
   32102           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   32103           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
   32104             :         }
   32105           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   32106           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
   32107             :         }
   32108             : 
   32109           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
   32110           0 :                 allow_remaining = true;
   32111             :         }
   32112             : 
   32113           0 :         return py_DnssrvOperation2_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
   32114             : }
   32115             : 
   32116           0 : static PyObject *py_DnssrvOperation2_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   32117             : {
   32118           0 :         DATA_BLOB blob;
   32119           0 :         Py_ssize_t blob_length = 0;
   32120           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
   32121           0 :         PyObject *bigendian_obj = NULL;
   32122           0 :         PyObject *ndr64_obj = NULL;
   32123           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
   32124           0 :         PyObject *allow_remaining_obj = NULL;
   32125           0 :         bool allow_remaining = false;
   32126             : 
   32127           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
   32128             :                 discard_const_p(char *, kwnames),
   32129             :                 &blob.data, &blob_length,
   32130             :                 &bigendian_obj,
   32131             :                 &ndr64_obj,
   32132             :                 &allow_remaining_obj)) {
   32133           0 :                 return NULL;
   32134             :         }
   32135           0 :         blob.length = blob_length;
   32136             : 
   32137           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   32138           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
   32139             :         }
   32140           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   32141           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
   32142             :         }
   32143             : 
   32144           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
   32145           0 :                 allow_remaining = true;
   32146             :         }
   32147             : 
   32148           0 :         return py_DnssrvOperation2_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
   32149             : }
   32150             : 
   32151           0 : static PyObject *py_DnssrvOperation2_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
   32152             : {
   32153           0 :         const struct ndr_interface_call *call = NULL;
   32154           0 :         struct DnssrvOperation2 *object = pytalloc_get_ptr(py_obj);
   32155           0 :         PyObject *ret;
   32156           0 :         char *retstr;
   32157             : 
   32158           0 :         if (ndr_table_dnsserver.num_calls < 6) {
   32159           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvOperation2_ndr_print");
   32160           0 :                 return NULL;
   32161             :         }
   32162           0 :         call = &ndr_table_dnsserver.calls[5];
   32163             : 
   32164           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
   32165           0 :         ret = PyUnicode_FromString(retstr);
   32166           0 :         TALLOC_FREE(retstr);
   32167             : 
   32168           0 :         return ret;
   32169             : }
   32170             : 
   32171           0 : static PyObject *py_DnssrvOperation2_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
   32172             : {
   32173           0 :         return py_DnssrvOperation2_ndr_print(py_obj, "DnssrvOperation2_in", NDR_IN);
   32174             : }
   32175             : 
   32176           0 : static PyObject *py_DnssrvOperation2_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
   32177             : {
   32178           0 :         return py_DnssrvOperation2_ndr_print(py_obj, "DnssrvOperation2_out", NDR_OUT);
   32179             : }
   32180             : 
   32181             : static PyMethodDef py_DnssrvOperation2_methods[] = {
   32182             :         { "opnum", (PyCFunction)py_DnssrvOperation2_ndr_opnum, METH_NOARGS|METH_CLASS,
   32183             :                 "dnsserver.DnssrvOperation2.opnum() -> 5 (0x05) " },
   32184             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvOperation2_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
   32185             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
   32186             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvOperation2_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
   32187             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
   32188             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvOperation2_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
   32189             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
   32190             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvOperation2_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
   32191             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
   32192             :         { "__ndr_print_in__", (PyCFunction)py_DnssrvOperation2_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
   32193             :         { "__ndr_print_out__", (PyCFunction)py_DnssrvOperation2_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
   32194             :         { NULL, NULL, 0, NULL }
   32195             : };
   32196             : 
   32197             : 
   32198             : static PyTypeObject DnssrvOperation2_Type = {
   32199             :         PyVarObject_HEAD_INIT(NULL, 0)
   32200             :         .tp_name = "dnsserver.DnssrvOperation2",
   32201             :         .tp_getset = py_DnssrvOperation2_getsetters,
   32202             :         .tp_methods = py_DnssrvOperation2_methods,
   32203             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   32204             :         .tp_new = py_DnssrvOperation2_new,
   32205             : };
   32206             : 
   32207        1652 : static bool pack_py_DnssrvOperation2_args_in(PyObject *args, PyObject *kwargs, struct DnssrvOperation2 *r)
   32208             : {
   32209           0 :         PyObject *py_dwClientVersion;
   32210           0 :         PyObject *py_dwSettingFlags;
   32211           0 :         PyObject *py_pwszServerName;
   32212           0 :         PyObject *py_pszZone;
   32213           0 :         PyObject *py_dwContext;
   32214           0 :         PyObject *py_pszOperation;
   32215           0 :         PyObject *py_dwTypeId;
   32216           0 :         PyObject *py_pData;
   32217        1652 :         const char *kwnames[] = {
   32218             :                 "dwClientVersion", "dwSettingFlags", "pwszServerName", "pszZone", "dwContext", "pszOperation", "dwTypeId", "pData", NULL
   32219             :         };
   32220             : 
   32221        1652 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOO:DnssrvOperation2", discard_const_p(char *, kwnames), &py_dwClientVersion, &py_dwSettingFlags, &py_pwszServerName, &py_pszZone, &py_dwContext, &py_pszOperation, &py_dwTypeId, &py_pData)) {
   32222           0 :                 return false;
   32223             :         }
   32224             : 
   32225        1652 :         if (py_dwClientVersion == NULL) {
   32226           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.dwClientVersion");
   32227           0 :                 return false;
   32228             :         }
   32229             :         {
   32230        1652 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.dwClientVersion));
   32231        1652 :                 if (PyLong_Check(py_dwClientVersion)) {
   32232           0 :                         unsigned long long test_var;
   32233        1652 :                         test_var = PyLong_AsUnsignedLongLong(py_dwClientVersion);
   32234        1652 :                         if (PyErr_Occurred() != NULL) {
   32235           0 :                                 return false;
   32236             :                         }
   32237        1652 :                         if (test_var > uint_max) {
   32238           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   32239             :                                   PyLong_Type.tp_name, uint_max, test_var);
   32240           0 :                                 return false;
   32241             :                         }
   32242        1652 :                         r->in.dwClientVersion = test_var;
   32243             :                 } else {
   32244           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   32245             :                           PyLong_Type.tp_name);
   32246           0 :                         return false;
   32247             :                 }
   32248             :         }
   32249        1652 :         if (py_dwSettingFlags == NULL) {
   32250           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.dwSettingFlags");
   32251           0 :                 return false;
   32252             :         }
   32253             :         {
   32254        1652 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.dwSettingFlags));
   32255        1652 :                 if (PyLong_Check(py_dwSettingFlags)) {
   32256           0 :                         unsigned long long test_var;
   32257        1652 :                         test_var = PyLong_AsUnsignedLongLong(py_dwSettingFlags);
   32258        1652 :                         if (PyErr_Occurred() != NULL) {
   32259           0 :                                 return false;
   32260             :                         }
   32261        1652 :                         if (test_var > uint_max) {
   32262           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   32263             :                                   PyLong_Type.tp_name, uint_max, test_var);
   32264           0 :                                 return false;
   32265             :                         }
   32266        1652 :                         r->in.dwSettingFlags = test_var;
   32267             :                 } else {
   32268           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   32269             :                           PyLong_Type.tp_name);
   32270           0 :                         return false;
   32271             :                 }
   32272             :         }
   32273        1652 :         if (py_pwszServerName == NULL) {
   32274           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pwszServerName");
   32275           0 :                 return false;
   32276             :         }
   32277        1652 :         if (py_pwszServerName == Py_None) {
   32278           0 :                 r->in.pwszServerName = NULL;
   32279             :         } else {
   32280        1652 :                 r->in.pwszServerName = NULL;
   32281             :                 {
   32282           0 :                         const char *test_str;
   32283           0 :                         const char *talloc_str;
   32284        1652 :                         PyObject *unicode = NULL;
   32285        1652 :                         if (PyUnicode_Check(py_pwszServerName)) {
   32286        1652 :                                 unicode = PyUnicode_AsEncodedString(py_pwszServerName, "utf-8", "ignore");
   32287        1652 :                                 if (unicode == NULL) {
   32288           0 :                                         return false;
   32289             :                                 }
   32290        1652 :                                 test_str = PyBytes_AS_STRING(unicode);
   32291           0 :                         } else if (PyBytes_Check(py_pwszServerName)) {
   32292           0 :                                 test_str = PyBytes_AS_STRING(py_pwszServerName);
   32293             :                         } else {
   32294           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pwszServerName)->tp_name);
   32295           0 :                                 return false;
   32296             :                         }
   32297        1652 :                         talloc_str = talloc_strdup(r, test_str);
   32298        1652 :                         if (unicode != NULL) {
   32299         954 :                                 Py_DECREF(unicode);
   32300             :                         }
   32301        1652 :                         if (talloc_str == NULL) {
   32302           0 :                                 PyErr_NoMemory();
   32303           0 :                                 return false;
   32304             :                         }
   32305        1652 :                         r->in.pwszServerName = talloc_str;
   32306             :                 }
   32307             :         }
   32308        1652 :         if (py_pszZone == NULL) {
   32309           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszZone");
   32310           0 :                 return false;
   32311             :         }
   32312        1652 :         if (py_pszZone == Py_None) {
   32313         429 :                 r->in.pszZone = NULL;
   32314             :         } else {
   32315        1223 :                 r->in.pszZone = NULL;
   32316             :                 {
   32317           0 :                         const char *test_str;
   32318           0 :                         const char *talloc_str;
   32319        1223 :                         PyObject *unicode = NULL;
   32320        1223 :                         if (PyUnicode_Check(py_pszZone)) {
   32321        1223 :                                 unicode = PyUnicode_AsEncodedString(py_pszZone, "utf-8", "ignore");
   32322        1223 :                                 if (unicode == NULL) {
   32323           0 :                                         return false;
   32324             :                                 }
   32325        1223 :                                 test_str = PyBytes_AS_STRING(unicode);
   32326           0 :                         } else if (PyBytes_Check(py_pszZone)) {
   32327           0 :                                 test_str = PyBytes_AS_STRING(py_pszZone);
   32328             :                         } else {
   32329           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszZone)->tp_name);
   32330           0 :                                 return false;
   32331             :                         }
   32332        1223 :                         talloc_str = talloc_strdup(r, test_str);
   32333        1223 :                         if (unicode != NULL) {
   32334         696 :                                 Py_DECREF(unicode);
   32335             :                         }
   32336        1223 :                         if (talloc_str == NULL) {
   32337           0 :                                 PyErr_NoMemory();
   32338           0 :                                 return false;
   32339             :                         }
   32340        1223 :                         r->in.pszZone = talloc_str;
   32341             :                 }
   32342             :         }
   32343        1652 :         if (py_dwContext == NULL) {
   32344           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.dwContext");
   32345           0 :                 return false;
   32346             :         }
   32347             :         {
   32348        1652 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.dwContext));
   32349        1652 :                 if (PyLong_Check(py_dwContext)) {
   32350           0 :                         unsigned long long test_var;
   32351        1652 :                         test_var = PyLong_AsUnsignedLongLong(py_dwContext);
   32352        1652 :                         if (PyErr_Occurred() != NULL) {
   32353           0 :                                 return false;
   32354             :                         }
   32355        1652 :                         if (test_var > uint_max) {
   32356           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   32357             :                                   PyLong_Type.tp_name, uint_max, test_var);
   32358           0 :                                 return false;
   32359             :                         }
   32360        1652 :                         r->in.dwContext = test_var;
   32361             :                 } else {
   32362           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   32363             :                           PyLong_Type.tp_name);
   32364           0 :                         return false;
   32365             :                 }
   32366             :         }
   32367        1652 :         if (py_pszOperation == NULL) {
   32368           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszOperation");
   32369           0 :                 return false;
   32370             :         }
   32371        1652 :         if (py_pszOperation == Py_None) {
   32372           0 :                 r->in.pszOperation = NULL;
   32373             :         } else {
   32374        1652 :                 r->in.pszOperation = NULL;
   32375             :                 {
   32376           0 :                         const char *test_str;
   32377           0 :                         const char *talloc_str;
   32378        1652 :                         PyObject *unicode = NULL;
   32379        1652 :                         if (PyUnicode_Check(py_pszOperation)) {
   32380        1652 :                                 unicode = PyUnicode_AsEncodedString(py_pszOperation, "utf-8", "ignore");
   32381        1652 :                                 if (unicode == NULL) {
   32382           0 :                                         return false;
   32383             :                                 }
   32384        1652 :                                 test_str = PyBytes_AS_STRING(unicode);
   32385           0 :                         } else if (PyBytes_Check(py_pszOperation)) {
   32386           0 :                                 test_str = PyBytes_AS_STRING(py_pszOperation);
   32387             :                         } else {
   32388           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszOperation)->tp_name);
   32389           0 :                                 return false;
   32390             :                         }
   32391        1652 :                         talloc_str = talloc_strdup(r, test_str);
   32392        1652 :                         if (unicode != NULL) {
   32393         954 :                                 Py_DECREF(unicode);
   32394             :                         }
   32395        1652 :                         if (talloc_str == NULL) {
   32396           0 :                                 PyErr_NoMemory();
   32397           0 :                                 return false;
   32398             :                         }
   32399        1652 :                         r->in.pszOperation = talloc_str;
   32400             :                 }
   32401             :         }
   32402        1652 :         if (py_dwTypeId == NULL) {
   32403           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.dwTypeId");
   32404           0 :                 return false;
   32405             :         }
   32406             :         {
   32407        1652 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.dwTypeId));
   32408        1652 :                 if (PyLong_Check(py_dwTypeId)) {
   32409           0 :                         unsigned long long test_var;
   32410        1652 :                         test_var = PyLong_AsUnsignedLongLong(py_dwTypeId);
   32411        1652 :                         if (PyErr_Occurred() != NULL) {
   32412           0 :                                 return false;
   32413             :                         }
   32414        1652 :                         if (test_var > uint_max) {
   32415           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   32416             :                                   PyLong_Type.tp_name, uint_max, test_var);
   32417           0 :                                 return false;
   32418             :                         }
   32419        1652 :                         r->in.dwTypeId = test_var;
   32420             :                 } else {
   32421           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   32422             :                           PyLong_Type.tp_name);
   32423           0 :                         return false;
   32424             :                 }
   32425             :         }
   32426        1652 :         if (py_pData == NULL) {
   32427           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pData");
   32428           0 :                 return false;
   32429             :         }
   32430             :         {
   32431           0 :                 union DNSSRV_RPC_UNION *pData_switch_0;
   32432        1652 :                 pData_switch_0 = (union DNSSRV_RPC_UNION *)pyrpc_export_union(&DNSSRV_RPC_UNION_Type, r, r->in.dwTypeId, py_pData, "union DNSSRV_RPC_UNION");
   32433        1652 :                 if (pData_switch_0 == NULL) {
   32434           0 :                         return false;
   32435             :                 }
   32436        1652 :                 r->in.pData = *pData_switch_0;
   32437             :         }
   32438        1652 :         return true;
   32439             : }
   32440             : 
   32441        1652 : static PyObject *unpack_py_DnssrvOperation2_args_out(struct DnssrvOperation2 *r)
   32442             : {
   32443           0 :         PyObject *result;
   32444        1652 :         result = Py_None;
   32445         954 :         Py_INCREF(result);
   32446        1652 :         if (!W_ERROR_IS_OK(r->out.result)) {
   32447          53 :                 PyErr_SetWERROR(r->out.result);
   32448          53 :                 return NULL;
   32449             :         }
   32450             : 
   32451        1599 :         return result;
   32452             : }
   32453             : 
   32454             : 
   32455           0 : static PyObject *py_DnssrvQuery2_in_get_dwClientVersion(PyObject *obj, void *closure)
   32456             : {
   32457           0 :         struct DnssrvQuery2 *object = pytalloc_get_ptr(obj);
   32458           0 :         PyObject *py_dwClientVersion;
   32459           0 :         py_dwClientVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->in.dwClientVersion));
   32460           0 :         return py_dwClientVersion;
   32461             : }
   32462             : 
   32463           0 : static int py_DnssrvQuery2_in_set_dwClientVersion(PyObject *py_obj, PyObject *value, void *closure)
   32464             : {
   32465           0 :         struct DnssrvQuery2 *object = pytalloc_get_ptr(py_obj);
   32466           0 :         if (value == NULL) {
   32467           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.dwClientVersion");
   32468           0 :                 return -1;
   32469             :         }
   32470             :         {
   32471           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.dwClientVersion));
   32472           0 :                 if (PyLong_Check(value)) {
   32473           0 :                         unsigned long long test_var;
   32474           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   32475           0 :                         if (PyErr_Occurred() != NULL) {
   32476           0 :                                 return -1;
   32477             :                         }
   32478           0 :                         if (test_var > uint_max) {
   32479           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   32480             :                                   PyLong_Type.tp_name, uint_max, test_var);
   32481           0 :                                 return -1;
   32482             :                         }
   32483           0 :                         object->in.dwClientVersion = test_var;
   32484             :                 } else {
   32485           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   32486             :                           PyLong_Type.tp_name);
   32487           0 :                         return -1;
   32488             :                 }
   32489             :         }
   32490           0 :         return 0;
   32491             : }
   32492             : 
   32493           0 : static PyObject *py_DnssrvQuery2_in_get_dwSettingFlags(PyObject *obj, void *closure)
   32494             : {
   32495           0 :         struct DnssrvQuery2 *object = pytalloc_get_ptr(obj);
   32496           0 :         PyObject *py_dwSettingFlags;
   32497           0 :         py_dwSettingFlags = PyLong_FromUnsignedLongLong((uint32_t)(object->in.dwSettingFlags));
   32498           0 :         return py_dwSettingFlags;
   32499             : }
   32500             : 
   32501           0 : static int py_DnssrvQuery2_in_set_dwSettingFlags(PyObject *py_obj, PyObject *value, void *closure)
   32502             : {
   32503           0 :         struct DnssrvQuery2 *object = pytalloc_get_ptr(py_obj);
   32504           0 :         if (value == NULL) {
   32505           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.dwSettingFlags");
   32506           0 :                 return -1;
   32507             :         }
   32508             :         {
   32509           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.dwSettingFlags));
   32510           0 :                 if (PyLong_Check(value)) {
   32511           0 :                         unsigned long long test_var;
   32512           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   32513           0 :                         if (PyErr_Occurred() != NULL) {
   32514           0 :                                 return -1;
   32515             :                         }
   32516           0 :                         if (test_var > uint_max) {
   32517           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   32518             :                                   PyLong_Type.tp_name, uint_max, test_var);
   32519           0 :                                 return -1;
   32520             :                         }
   32521           0 :                         object->in.dwSettingFlags = test_var;
   32522             :                 } else {
   32523           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   32524             :                           PyLong_Type.tp_name);
   32525           0 :                         return -1;
   32526             :                 }
   32527             :         }
   32528           0 :         return 0;
   32529             : }
   32530             : 
   32531           0 : static PyObject *py_DnssrvQuery2_in_get_pwszServerName(PyObject *obj, void *closure)
   32532             : {
   32533           0 :         struct DnssrvQuery2 *object = pytalloc_get_ptr(obj);
   32534           0 :         PyObject *py_pwszServerName;
   32535           0 :         if (object->in.pwszServerName == NULL) {
   32536           0 :                 Py_RETURN_NONE;
   32537             :         }
   32538           0 :         if (object->in.pwszServerName == NULL) {
   32539           0 :                 py_pwszServerName = Py_None;
   32540           0 :                 Py_INCREF(py_pwszServerName);
   32541             :         } else {
   32542           0 :                 if (object->in.pwszServerName == NULL) {
   32543           0 :                         py_pwszServerName = Py_None;
   32544           0 :                         Py_INCREF(py_pwszServerName);
   32545             :                 } else {
   32546           0 :                         py_pwszServerName = PyUnicode_Decode(object->in.pwszServerName, strlen(object->in.pwszServerName), "utf-8", "ignore");
   32547             :                 }
   32548             :         }
   32549           0 :         return py_pwszServerName;
   32550             : }
   32551             : 
   32552           0 : static int py_DnssrvQuery2_in_set_pwszServerName(PyObject *py_obj, PyObject *value, void *closure)
   32553             : {
   32554           0 :         struct DnssrvQuery2 *object = pytalloc_get_ptr(py_obj);
   32555           0 :         if (value == NULL) {
   32556           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pwszServerName");
   32557           0 :                 return -1;
   32558             :         }
   32559           0 :         if (value == Py_None) {
   32560           0 :                 object->in.pwszServerName = NULL;
   32561             :         } else {
   32562           0 :                 object->in.pwszServerName = NULL;
   32563             :                 {
   32564           0 :                         const char *test_str;
   32565           0 :                         const char *talloc_str;
   32566           0 :                         PyObject *unicode = NULL;
   32567           0 :                         if (PyUnicode_Check(value)) {
   32568           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   32569           0 :                                 if (unicode == NULL) {
   32570           0 :                                         return -1;
   32571             :                                 }
   32572           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   32573           0 :                         } else if (PyBytes_Check(value)) {
   32574           0 :                                 test_str = PyBytes_AS_STRING(value);
   32575             :                         } else {
   32576           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   32577           0 :                                 return -1;
   32578             :                         }
   32579           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   32580           0 :                         if (unicode != NULL) {
   32581           0 :                                 Py_DECREF(unicode);
   32582             :                         }
   32583           0 :                         if (talloc_str == NULL) {
   32584           0 :                                 PyErr_NoMemory();
   32585           0 :                                 return -1;
   32586             :                         }
   32587           0 :                         object->in.pwszServerName = talloc_str;
   32588             :                 }
   32589             :         }
   32590           0 :         return 0;
   32591             : }
   32592             : 
   32593           0 : static PyObject *py_DnssrvQuery2_in_get_pszZone(PyObject *obj, void *closure)
   32594             : {
   32595           0 :         struct DnssrvQuery2 *object = pytalloc_get_ptr(obj);
   32596           0 :         PyObject *py_pszZone;
   32597           0 :         if (object->in.pszZone == NULL) {
   32598           0 :                 Py_RETURN_NONE;
   32599             :         }
   32600           0 :         if (object->in.pszZone == NULL) {
   32601           0 :                 py_pszZone = Py_None;
   32602           0 :                 Py_INCREF(py_pszZone);
   32603             :         } else {
   32604           0 :                 if (object->in.pszZone == NULL) {
   32605           0 :                         py_pszZone = Py_None;
   32606           0 :                         Py_INCREF(py_pszZone);
   32607             :                 } else {
   32608           0 :                         py_pszZone = PyUnicode_Decode(object->in.pszZone, strlen(object->in.pszZone), "utf-8", "ignore");
   32609             :                 }
   32610             :         }
   32611           0 :         return py_pszZone;
   32612             : }
   32613             : 
   32614           0 : static int py_DnssrvQuery2_in_set_pszZone(PyObject *py_obj, PyObject *value, void *closure)
   32615             : {
   32616           0 :         struct DnssrvQuery2 *object = pytalloc_get_ptr(py_obj);
   32617           0 :         if (value == NULL) {
   32618           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszZone");
   32619           0 :                 return -1;
   32620             :         }
   32621           0 :         if (value == Py_None) {
   32622           0 :                 object->in.pszZone = NULL;
   32623             :         } else {
   32624           0 :                 object->in.pszZone = NULL;
   32625             :                 {
   32626           0 :                         const char *test_str;
   32627           0 :                         const char *talloc_str;
   32628           0 :                         PyObject *unicode = NULL;
   32629           0 :                         if (PyUnicode_Check(value)) {
   32630           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   32631           0 :                                 if (unicode == NULL) {
   32632           0 :                                         return -1;
   32633             :                                 }
   32634           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   32635           0 :                         } else if (PyBytes_Check(value)) {
   32636           0 :                                 test_str = PyBytes_AS_STRING(value);
   32637             :                         } else {
   32638           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   32639           0 :                                 return -1;
   32640             :                         }
   32641           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   32642           0 :                         if (unicode != NULL) {
   32643           0 :                                 Py_DECREF(unicode);
   32644             :                         }
   32645           0 :                         if (talloc_str == NULL) {
   32646           0 :                                 PyErr_NoMemory();
   32647           0 :                                 return -1;
   32648             :                         }
   32649           0 :                         object->in.pszZone = talloc_str;
   32650             :                 }
   32651             :         }
   32652           0 :         return 0;
   32653             : }
   32654             : 
   32655           0 : static PyObject *py_DnssrvQuery2_in_get_pszOperation(PyObject *obj, void *closure)
   32656             : {
   32657           0 :         struct DnssrvQuery2 *object = pytalloc_get_ptr(obj);
   32658           0 :         PyObject *py_pszOperation;
   32659           0 :         if (object->in.pszOperation == NULL) {
   32660           0 :                 Py_RETURN_NONE;
   32661             :         }
   32662           0 :         if (object->in.pszOperation == NULL) {
   32663           0 :                 py_pszOperation = Py_None;
   32664           0 :                 Py_INCREF(py_pszOperation);
   32665             :         } else {
   32666           0 :                 if (object->in.pszOperation == NULL) {
   32667           0 :                         py_pszOperation = Py_None;
   32668           0 :                         Py_INCREF(py_pszOperation);
   32669             :                 } else {
   32670           0 :                         py_pszOperation = PyUnicode_Decode(object->in.pszOperation, strlen(object->in.pszOperation), "utf-8", "ignore");
   32671             :                 }
   32672             :         }
   32673           0 :         return py_pszOperation;
   32674             : }
   32675             : 
   32676           0 : static int py_DnssrvQuery2_in_set_pszOperation(PyObject *py_obj, PyObject *value, void *closure)
   32677             : {
   32678           0 :         struct DnssrvQuery2 *object = pytalloc_get_ptr(py_obj);
   32679           0 :         if (value == NULL) {
   32680           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszOperation");
   32681           0 :                 return -1;
   32682             :         }
   32683           0 :         if (value == Py_None) {
   32684           0 :                 object->in.pszOperation = NULL;
   32685             :         } else {
   32686           0 :                 object->in.pszOperation = NULL;
   32687             :                 {
   32688           0 :                         const char *test_str;
   32689           0 :                         const char *talloc_str;
   32690           0 :                         PyObject *unicode = NULL;
   32691           0 :                         if (PyUnicode_Check(value)) {
   32692           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   32693           0 :                                 if (unicode == NULL) {
   32694           0 :                                         return -1;
   32695             :                                 }
   32696           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   32697           0 :                         } else if (PyBytes_Check(value)) {
   32698           0 :                                 test_str = PyBytes_AS_STRING(value);
   32699             :                         } else {
   32700           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   32701           0 :                                 return -1;
   32702             :                         }
   32703           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   32704           0 :                         if (unicode != NULL) {
   32705           0 :                                 Py_DECREF(unicode);
   32706             :                         }
   32707           0 :                         if (talloc_str == NULL) {
   32708           0 :                                 PyErr_NoMemory();
   32709           0 :                                 return -1;
   32710             :                         }
   32711           0 :                         object->in.pszOperation = talloc_str;
   32712             :                 }
   32713             :         }
   32714           0 :         return 0;
   32715             : }
   32716             : 
   32717           0 : static PyObject *py_DnssrvQuery2_out_get_pdwTypeId(PyObject *obj, void *closure)
   32718             : {
   32719           0 :         struct DnssrvQuery2 *object = pytalloc_get_ptr(obj);
   32720           0 :         PyObject *py_pdwTypeId;
   32721           0 :         if (object->out.pdwTypeId == NULL) {
   32722           0 :                 Py_RETURN_NONE;
   32723             :         }
   32724           0 :         py_pdwTypeId = PyLong_FromUnsignedLongLong((uint32_t)(*object->out.pdwTypeId));
   32725           0 :         return py_pdwTypeId;
   32726             : }
   32727             : 
   32728           0 : static int py_DnssrvQuery2_out_set_pdwTypeId(PyObject *py_obj, PyObject *value, void *closure)
   32729             : {
   32730           0 :         struct DnssrvQuery2 *object = pytalloc_get_ptr(py_obj);
   32731           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.pdwTypeId));
   32732           0 :         if (value == NULL) {
   32733           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.pdwTypeId");
   32734           0 :                 return -1;
   32735             :         }
   32736           0 :         object->out.pdwTypeId = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.pdwTypeId);
   32737           0 :         if (object->out.pdwTypeId == NULL) {
   32738           0 :                 PyErr_NoMemory();
   32739           0 :                 return -1;
   32740             :         }
   32741             :         {
   32742           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->out.pdwTypeId));
   32743           0 :                 if (PyLong_Check(value)) {
   32744           0 :                         unsigned long long test_var;
   32745           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   32746           0 :                         if (PyErr_Occurred() != NULL) {
   32747           0 :                                 return -1;
   32748             :                         }
   32749           0 :                         if (test_var > uint_max) {
   32750           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   32751             :                                   PyLong_Type.tp_name, uint_max, test_var);
   32752           0 :                                 return -1;
   32753             :                         }
   32754           0 :                         *object->out.pdwTypeId = test_var;
   32755             :                 } else {
   32756           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   32757             :                           PyLong_Type.tp_name);
   32758           0 :                         return -1;
   32759             :                 }
   32760             :         }
   32761           0 :         return 0;
   32762             : }
   32763             : 
   32764           0 : static PyObject *py_DnssrvQuery2_out_get_ppData(PyObject *obj, void *closure)
   32765             : {
   32766           0 :         struct DnssrvQuery2 *object = pytalloc_get_ptr(obj);
   32767           0 :         PyObject *py_ppData;
   32768           0 :         if (object->out.ppData == NULL) {
   32769           0 :                 Py_RETURN_NONE;
   32770             :         }
   32771           0 :         py_ppData = pyrpc_import_union(&DNSSRV_RPC_UNION_Type, object->out.ppData, *object->out.pdwTypeId, object->out.ppData, "union DNSSRV_RPC_UNION");
   32772           0 :         if (py_ppData == NULL) {
   32773           0 :                 return NULL;
   32774             :         }
   32775           0 :         return py_ppData;
   32776             : }
   32777             : 
   32778           0 : static int py_DnssrvQuery2_out_set_ppData(PyObject *py_obj, PyObject *value, void *closure)
   32779             : {
   32780           0 :         struct DnssrvQuery2 *object = pytalloc_get_ptr(py_obj);
   32781           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.ppData));
   32782           0 :         if (value == NULL) {
   32783           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.ppData");
   32784           0 :                 return -1;
   32785             :         }
   32786           0 :         object->out.ppData = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.ppData);
   32787           0 :         if (object->out.ppData == NULL) {
   32788           0 :                 PyErr_NoMemory();
   32789           0 :                 return -1;
   32790             :         }
   32791             :         {
   32792           0 :                 union DNSSRV_RPC_UNION *ppData_switch_1;
   32793           0 :                 ppData_switch_1 = (union DNSSRV_RPC_UNION *)pyrpc_export_union(&DNSSRV_RPC_UNION_Type, pytalloc_get_mem_ctx(py_obj), *object->out.pdwTypeId, value, "union DNSSRV_RPC_UNION");
   32794           0 :                 if (ppData_switch_1 == NULL) {
   32795           0 :                         return -1;
   32796             :                 }
   32797           0 :                 object->out.ppData = ppData_switch_1;
   32798             :         }
   32799           0 :         return 0;
   32800             : }
   32801             : 
   32802           0 : static PyObject *py_DnssrvQuery2_get_result(PyObject *obj, void *closure)
   32803             : {
   32804           0 :         struct DnssrvQuery2 *object = pytalloc_get_ptr(obj);
   32805           0 :         PyObject *py_result;
   32806           0 :         py_result = PyErr_FromWERROR(object->out.result);
   32807           0 :         return py_result;
   32808             : }
   32809             : 
   32810           0 : static int py_DnssrvQuery2_set_result(PyObject *py_obj, PyObject *value, void *closure)
   32811             : {
   32812           0 :         struct DnssrvQuery2 *object = pytalloc_get_ptr(py_obj);
   32813           0 :         if (value == NULL) {
   32814           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.result");
   32815           0 :                 return -1;
   32816             :         }
   32817           0 :         object->out.result = W_ERROR(PyLong_AsLong(value));
   32818           0 :         return 0;
   32819             : }
   32820             : 
   32821             : static PyGetSetDef py_DnssrvQuery2_getsetters[] = {
   32822             :         {
   32823             :                 .name = discard_const_p(char, "in_dwClientVersion"),
   32824             :                 .get = py_DnssrvQuery2_in_get_dwClientVersion,
   32825             :                 .set = py_DnssrvQuery2_in_set_dwClientVersion,
   32826             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_CLIENT_VERSION")
   32827             :         },
   32828             :         {
   32829             :                 .name = discard_const_p(char, "in_dwSettingFlags"),
   32830             :                 .get = py_DnssrvQuery2_in_get_dwSettingFlags,
   32831             :                 .set = py_DnssrvQuery2_in_set_dwSettingFlags,
   32832             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   32833             :         },
   32834             :         {
   32835             :                 .name = discard_const_p(char, "in_pwszServerName"),
   32836             :                 .get = py_DnssrvQuery2_in_get_pwszServerName,
   32837             :                 .set = py_DnssrvQuery2_in_set_pwszServerName,
   32838             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
   32839             :         },
   32840             :         {
   32841             :                 .name = discard_const_p(char, "in_pszZone"),
   32842             :                 .get = py_DnssrvQuery2_in_get_pszZone,
   32843             :                 .set = py_DnssrvQuery2_in_set_pszZone,
   32844             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   32845             :         },
   32846             :         {
   32847             :                 .name = discard_const_p(char, "in_pszOperation"),
   32848             :                 .get = py_DnssrvQuery2_in_get_pszOperation,
   32849             :                 .set = py_DnssrvQuery2_in_set_pszOperation,
   32850             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   32851             :         },
   32852             :         {
   32853             :                 .name = discard_const_p(char, "out_pdwTypeId"),
   32854             :                 .get = py_DnssrvQuery2_out_get_pdwTypeId,
   32855             :                 .set = py_DnssrvQuery2_out_set_pdwTypeId,
   32856             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_TYPEID")
   32857             :         },
   32858             :         {
   32859             :                 .name = discard_const_p(char, "out_ppData"),
   32860             :                 .get = py_DnssrvQuery2_out_get_ppData,
   32861             :                 .set = py_DnssrvQuery2_out_set_ppData,
   32862             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNSSRV_RPC_UNION")
   32863             :         },
   32864             :         {
   32865             :                 .name = discard_const_p(char, "result"),
   32866             :                 .get = py_DnssrvQuery2_get_result,
   32867             :                 .set = py_DnssrvQuery2_set_result,
   32868             :                 .doc = discard_const_p(char, "PIDL-generated element of type WERROR")
   32869             :         },
   32870             :         { .name = NULL }
   32871             : };
   32872             : 
   32873           0 : static PyObject *py_DnssrvQuery2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   32874             : {
   32875           0 :         PyObject *self = pytalloc_new(struct DnssrvQuery2, type);
   32876           0 :         struct DnssrvQuery2 *_self = (struct DnssrvQuery2 *)pytalloc_get_ptr(self);
   32877           0 :         TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
   32878           0 :         _self->out.pdwTypeId = talloc_zero(mem_ctx, enum DNS_RPC_TYPEID);
   32879           0 :         _self->out.ppData = talloc_zero(mem_ctx, union DNSSRV_RPC_UNION);
   32880           0 :         return self;
   32881             : }
   32882             : 
   32883           0 : static PyObject *py_DnssrvQuery2_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
   32884             : {
   32885             : 
   32886             : 
   32887           0 :         return PyLong_FromLong(6);
   32888             : }
   32889             : 
   32890           0 : static PyObject *py_DnssrvQuery2_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
   32891             : {
   32892           0 :         const struct ndr_interface_call *call = NULL;
   32893           0 :         struct DnssrvQuery2 *object = pytalloc_get_ptr(py_obj);
   32894           0 :         PyObject *ret = NULL;
   32895           0 :         struct ndr_push *push = NULL;
   32896           0 :         DATA_BLOB blob;
   32897           0 :         enum ndr_err_code err;
   32898             : 
   32899           0 :         if (ndr_table_dnsserver.num_calls < 7) {
   32900           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvQuery2_ndr_pack");
   32901           0 :                 return NULL;
   32902             :         }
   32903           0 :         call = &ndr_table_dnsserver.calls[6];
   32904             : 
   32905           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
   32906           0 :         if (push == NULL) {
   32907           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
   32908           0 :                 return NULL;
   32909             :         }
   32910             : 
   32911           0 :         push->flags |= ndr_push_flags;
   32912             : 
   32913           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
   32914           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   32915           0 :                 TALLOC_FREE(push);
   32916           0 :                 PyErr_SetNdrError(err);
   32917           0 :                 return NULL;
   32918             :         }
   32919           0 :         blob = ndr_push_blob(push);
   32920           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
   32921           0 :         TALLOC_FREE(push);
   32922           0 :         return ret;
   32923             : }
   32924             : 
   32925           0 : static PyObject *py_DnssrvQuery2_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   32926             : {
   32927           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
   32928           0 :         PyObject *bigendian_obj = NULL;
   32929           0 :         PyObject *ndr64_obj = NULL;
   32930           0 :         libndr_flags ndr_push_flags = 0;
   32931             : 
   32932           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
   32933             :                 discard_const_p(char *, kwnames),
   32934             :                 &bigendian_obj,
   32935             :                 &ndr64_obj)) {
   32936           0 :                 return NULL;
   32937             :         }
   32938             : 
   32939           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   32940           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
   32941             :         }
   32942           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   32943           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
   32944             :         }
   32945             : 
   32946           0 :         return py_DnssrvQuery2_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
   32947             : }
   32948             : 
   32949           0 : static PyObject *py_DnssrvQuery2_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   32950             : {
   32951           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
   32952           0 :         PyObject *bigendian_obj = NULL;
   32953           0 :         PyObject *ndr64_obj = NULL;
   32954           0 :         libndr_flags ndr_push_flags = 0;
   32955             : 
   32956           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
   32957             :                 discard_const_p(char *, kwnames),
   32958             :                 &bigendian_obj,
   32959             :                 &ndr64_obj)) {
   32960           0 :                 return NULL;
   32961             :         }
   32962             : 
   32963           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   32964           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
   32965             :         }
   32966           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   32967           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
   32968             :         }
   32969             : 
   32970           0 :         return py_DnssrvQuery2_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
   32971             : }
   32972             : 
   32973           0 : static PyObject *py_DnssrvQuery2_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
   32974             : {
   32975           0 :         const struct ndr_interface_call *call = NULL;
   32976           0 :         struct DnssrvQuery2 *object = pytalloc_get_ptr(py_obj);
   32977           0 :         struct ndr_pull *pull = NULL;
   32978           0 :         enum ndr_err_code err;
   32979             : 
   32980           0 :         if (ndr_table_dnsserver.num_calls < 7) {
   32981           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvQuery2_ndr_unpack");
   32982           0 :                 return NULL;
   32983             :         }
   32984           0 :         call = &ndr_table_dnsserver.calls[6];
   32985             : 
   32986           0 :         pull = ndr_pull_init_blob(blob, object);
   32987           0 :         if (pull == NULL) {
   32988           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
   32989           0 :                 return NULL;
   32990             :         }
   32991             : 
   32992           0 :         pull->flags |= ndr_pull_flags;
   32993             : 
   32994           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
   32995           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   32996           0 :                 TALLOC_FREE(pull);
   32997           0 :                 PyErr_SetNdrError(err);
   32998           0 :                 return NULL;
   32999             :         }
   33000           0 :         if (!allow_remaining) {
   33001           0 :                 uint32_t highest_ofs;
   33002             : 
   33003           0 :                 if (pull->offset > pull->relative_highest_offset) {
   33004           0 :                         highest_ofs = pull->offset;
   33005             :                 } else {
   33006           0 :                         highest_ofs = pull->relative_highest_offset;
   33007             :                 }
   33008           0 :                 if (highest_ofs < pull->data_size) {
   33009           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
   33010             :                                 "not all bytes consumed ofs[%u] size[%u]",
   33011             :                                 highest_ofs, pull->data_size);
   33012           0 :                         TALLOC_FREE(pull);
   33013           0 :                         PyErr_SetNdrError(err);
   33014           0 :                         return NULL;
   33015             :                 }
   33016             :         }
   33017             : 
   33018           0 :         TALLOC_FREE(pull);
   33019           0 :         Py_RETURN_NONE;
   33020             : }
   33021             : 
   33022           0 : static PyObject *py_DnssrvQuery2_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   33023             : {
   33024           0 :         DATA_BLOB blob;
   33025           0 :         Py_ssize_t blob_length = 0;
   33026           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
   33027           0 :         PyObject *bigendian_obj = NULL;
   33028           0 :         PyObject *ndr64_obj = NULL;
   33029           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
   33030           0 :         PyObject *allow_remaining_obj = NULL;
   33031           0 :         bool allow_remaining = false;
   33032             : 
   33033           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
   33034             :                 discard_const_p(char *, kwnames),
   33035             :                 &blob.data, &blob_length,
   33036             :                 &bigendian_obj,
   33037             :                 &ndr64_obj,
   33038             :                 &allow_remaining_obj)) {
   33039           0 :                 return NULL;
   33040             :         }
   33041           0 :         blob.length = blob_length;
   33042             : 
   33043           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   33044           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
   33045             :         }
   33046           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   33047           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
   33048             :         }
   33049             : 
   33050           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
   33051           0 :                 allow_remaining = true;
   33052             :         }
   33053             : 
   33054           0 :         return py_DnssrvQuery2_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
   33055             : }
   33056             : 
   33057           0 : static PyObject *py_DnssrvQuery2_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   33058             : {
   33059           0 :         DATA_BLOB blob;
   33060           0 :         Py_ssize_t blob_length = 0;
   33061           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
   33062           0 :         PyObject *bigendian_obj = NULL;
   33063           0 :         PyObject *ndr64_obj = NULL;
   33064           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
   33065           0 :         PyObject *allow_remaining_obj = NULL;
   33066           0 :         bool allow_remaining = false;
   33067             : 
   33068           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
   33069             :                 discard_const_p(char *, kwnames),
   33070             :                 &blob.data, &blob_length,
   33071             :                 &bigendian_obj,
   33072             :                 &ndr64_obj,
   33073             :                 &allow_remaining_obj)) {
   33074           0 :                 return NULL;
   33075             :         }
   33076           0 :         blob.length = blob_length;
   33077             : 
   33078           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   33079           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
   33080             :         }
   33081           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   33082           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
   33083             :         }
   33084             : 
   33085           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
   33086           0 :                 allow_remaining = true;
   33087             :         }
   33088             : 
   33089           0 :         return py_DnssrvQuery2_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
   33090             : }
   33091             : 
   33092           0 : static PyObject *py_DnssrvQuery2_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
   33093             : {
   33094           0 :         const struct ndr_interface_call *call = NULL;
   33095           0 :         struct DnssrvQuery2 *object = pytalloc_get_ptr(py_obj);
   33096           0 :         PyObject *ret;
   33097           0 :         char *retstr;
   33098             : 
   33099           0 :         if (ndr_table_dnsserver.num_calls < 7) {
   33100           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvQuery2_ndr_print");
   33101           0 :                 return NULL;
   33102             :         }
   33103           0 :         call = &ndr_table_dnsserver.calls[6];
   33104             : 
   33105           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
   33106           0 :         ret = PyUnicode_FromString(retstr);
   33107           0 :         TALLOC_FREE(retstr);
   33108             : 
   33109           0 :         return ret;
   33110             : }
   33111             : 
   33112           0 : static PyObject *py_DnssrvQuery2_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
   33113             : {
   33114           0 :         return py_DnssrvQuery2_ndr_print(py_obj, "DnssrvQuery2_in", NDR_IN);
   33115             : }
   33116             : 
   33117           0 : static PyObject *py_DnssrvQuery2_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
   33118             : {
   33119           0 :         return py_DnssrvQuery2_ndr_print(py_obj, "DnssrvQuery2_out", NDR_OUT);
   33120             : }
   33121             : 
   33122             : static PyMethodDef py_DnssrvQuery2_methods[] = {
   33123             :         { "opnum", (PyCFunction)py_DnssrvQuery2_ndr_opnum, METH_NOARGS|METH_CLASS,
   33124             :                 "dnsserver.DnssrvQuery2.opnum() -> 6 (0x06) " },
   33125             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvQuery2_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
   33126             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
   33127             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvQuery2_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
   33128             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
   33129             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvQuery2_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
   33130             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
   33131             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvQuery2_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
   33132             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
   33133             :         { "__ndr_print_in__", (PyCFunction)py_DnssrvQuery2_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
   33134             :         { "__ndr_print_out__", (PyCFunction)py_DnssrvQuery2_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
   33135             :         { NULL, NULL, 0, NULL }
   33136             : };
   33137             : 
   33138             : 
   33139             : static PyTypeObject DnssrvQuery2_Type = {
   33140             :         PyVarObject_HEAD_INIT(NULL, 0)
   33141             :         .tp_name = "dnsserver.DnssrvQuery2",
   33142             :         .tp_getset = py_DnssrvQuery2_getsetters,
   33143             :         .tp_methods = py_DnssrvQuery2_methods,
   33144             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   33145             :         .tp_new = py_DnssrvQuery2_new,
   33146             : };
   33147             : 
   33148          29 : static bool pack_py_DnssrvQuery2_args_in(PyObject *args, PyObject *kwargs, struct DnssrvQuery2 *r)
   33149             : {
   33150           0 :         PyObject *py_dwClientVersion;
   33151           0 :         PyObject *py_dwSettingFlags;
   33152           0 :         PyObject *py_pwszServerName;
   33153           0 :         PyObject *py_pszZone;
   33154           0 :         PyObject *py_pszOperation;
   33155          29 :         const char *kwnames[] = {
   33156             :                 "dwClientVersion", "dwSettingFlags", "pwszServerName", "pszZone", "pszOperation", NULL
   33157             :         };
   33158             : 
   33159          29 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:DnssrvQuery2", discard_const_p(char *, kwnames), &py_dwClientVersion, &py_dwSettingFlags, &py_pwszServerName, &py_pszZone, &py_pszOperation)) {
   33160           0 :                 return false;
   33161             :         }
   33162             : 
   33163          29 :         if (py_dwClientVersion == NULL) {
   33164           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.dwClientVersion");
   33165           0 :                 return false;
   33166             :         }
   33167             :         {
   33168          29 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.dwClientVersion));
   33169          29 :                 if (PyLong_Check(py_dwClientVersion)) {
   33170           0 :                         unsigned long long test_var;
   33171          29 :                         test_var = PyLong_AsUnsignedLongLong(py_dwClientVersion);
   33172          29 :                         if (PyErr_Occurred() != NULL) {
   33173           0 :                                 return false;
   33174             :                         }
   33175          29 :                         if (test_var > uint_max) {
   33176           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   33177             :                                   PyLong_Type.tp_name, uint_max, test_var);
   33178           0 :                                 return false;
   33179             :                         }
   33180          29 :                         r->in.dwClientVersion = test_var;
   33181             :                 } else {
   33182           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   33183             :                           PyLong_Type.tp_name);
   33184           0 :                         return false;
   33185             :                 }
   33186             :         }
   33187          29 :         if (py_dwSettingFlags == NULL) {
   33188           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.dwSettingFlags");
   33189           0 :                 return false;
   33190             :         }
   33191             :         {
   33192          29 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.dwSettingFlags));
   33193          29 :                 if (PyLong_Check(py_dwSettingFlags)) {
   33194           0 :                         unsigned long long test_var;
   33195          29 :                         test_var = PyLong_AsUnsignedLongLong(py_dwSettingFlags);
   33196          29 :                         if (PyErr_Occurred() != NULL) {
   33197           0 :                                 return false;
   33198             :                         }
   33199          29 :                         if (test_var > uint_max) {
   33200           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   33201             :                                   PyLong_Type.tp_name, uint_max, test_var);
   33202           0 :                                 return false;
   33203             :                         }
   33204          29 :                         r->in.dwSettingFlags = test_var;
   33205             :                 } else {
   33206           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   33207             :                           PyLong_Type.tp_name);
   33208           0 :                         return false;
   33209             :                 }
   33210             :         }
   33211          29 :         if (py_pwszServerName == NULL) {
   33212           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pwszServerName");
   33213           0 :                 return false;
   33214             :         }
   33215          29 :         if (py_pwszServerName == Py_None) {
   33216           0 :                 r->in.pwszServerName = NULL;
   33217             :         } else {
   33218          29 :                 r->in.pwszServerName = NULL;
   33219             :                 {
   33220           0 :                         const char *test_str;
   33221           0 :                         const char *talloc_str;
   33222          29 :                         PyObject *unicode = NULL;
   33223          29 :                         if (PyUnicode_Check(py_pwszServerName)) {
   33224          29 :                                 unicode = PyUnicode_AsEncodedString(py_pwszServerName, "utf-8", "ignore");
   33225          29 :                                 if (unicode == NULL) {
   33226           0 :                                         return false;
   33227             :                                 }
   33228          29 :                                 test_str = PyBytes_AS_STRING(unicode);
   33229           0 :                         } else if (PyBytes_Check(py_pwszServerName)) {
   33230           0 :                                 test_str = PyBytes_AS_STRING(py_pwszServerName);
   33231             :                         } else {
   33232           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pwszServerName)->tp_name);
   33233           0 :                                 return false;
   33234             :                         }
   33235          29 :                         talloc_str = talloc_strdup(r, test_str);
   33236          29 :                         if (unicode != NULL) {
   33237          26 :                                 Py_DECREF(unicode);
   33238             :                         }
   33239          29 :                         if (talloc_str == NULL) {
   33240           0 :                                 PyErr_NoMemory();
   33241           0 :                                 return false;
   33242             :                         }
   33243          29 :                         r->in.pwszServerName = talloc_str;
   33244             :                 }
   33245             :         }
   33246          29 :         if (py_pszZone == NULL) {
   33247           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszZone");
   33248           0 :                 return false;
   33249             :         }
   33250          29 :         if (py_pszZone == Py_None) {
   33251          12 :                 r->in.pszZone = NULL;
   33252             :         } else {
   33253          17 :                 r->in.pszZone = NULL;
   33254             :                 {
   33255           0 :                         const char *test_str;
   33256           0 :                         const char *talloc_str;
   33257          17 :                         PyObject *unicode = NULL;
   33258          17 :                         if (PyUnicode_Check(py_pszZone)) {
   33259          17 :                                 unicode = PyUnicode_AsEncodedString(py_pszZone, "utf-8", "ignore");
   33260          17 :                                 if (unicode == NULL) {
   33261           0 :                                         return false;
   33262             :                                 }
   33263          17 :                                 test_str = PyBytes_AS_STRING(unicode);
   33264           0 :                         } else if (PyBytes_Check(py_pszZone)) {
   33265           0 :                                 test_str = PyBytes_AS_STRING(py_pszZone);
   33266             :                         } else {
   33267           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszZone)->tp_name);
   33268           0 :                                 return false;
   33269             :                         }
   33270          17 :                         talloc_str = talloc_strdup(r, test_str);
   33271          17 :                         if (unicode != NULL) {
   33272          17 :                                 Py_DECREF(unicode);
   33273             :                         }
   33274          17 :                         if (talloc_str == NULL) {
   33275           0 :                                 PyErr_NoMemory();
   33276           0 :                                 return false;
   33277             :                         }
   33278          17 :                         r->in.pszZone = talloc_str;
   33279             :                 }
   33280             :         }
   33281          29 :         if (py_pszOperation == NULL) {
   33282           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszOperation");
   33283           0 :                 return false;
   33284             :         }
   33285          29 :         if (py_pszOperation == Py_None) {
   33286           0 :                 r->in.pszOperation = NULL;
   33287             :         } else {
   33288          29 :                 r->in.pszOperation = NULL;
   33289             :                 {
   33290           0 :                         const char *test_str;
   33291           0 :                         const char *talloc_str;
   33292          29 :                         PyObject *unicode = NULL;
   33293          29 :                         if (PyUnicode_Check(py_pszOperation)) {
   33294          29 :                                 unicode = PyUnicode_AsEncodedString(py_pszOperation, "utf-8", "ignore");
   33295          29 :                                 if (unicode == NULL) {
   33296           0 :                                         return false;
   33297             :                                 }
   33298          29 :                                 test_str = PyBytes_AS_STRING(unicode);
   33299           0 :                         } else if (PyBytes_Check(py_pszOperation)) {
   33300           0 :                                 test_str = PyBytes_AS_STRING(py_pszOperation);
   33301             :                         } else {
   33302           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszOperation)->tp_name);
   33303           0 :                                 return false;
   33304             :                         }
   33305          29 :                         talloc_str = talloc_strdup(r, test_str);
   33306          29 :                         if (unicode != NULL) {
   33307          26 :                                 Py_DECREF(unicode);
   33308             :                         }
   33309          29 :                         if (talloc_str == NULL) {
   33310           0 :                                 PyErr_NoMemory();
   33311           0 :                                 return false;
   33312             :                         }
   33313          29 :                         r->in.pszOperation = talloc_str;
   33314             :                 }
   33315             :         }
   33316          29 :         return true;
   33317             : }
   33318             : 
   33319          29 : static PyObject *unpack_py_DnssrvQuery2_args_out(struct DnssrvQuery2 *r)
   33320             : {
   33321           0 :         PyObject *result;
   33322           0 :         PyObject *py_pdwTypeId;
   33323           0 :         PyObject *py_ppData;
   33324          29 :         result = PyTuple_New(2);
   33325          29 :         py_pdwTypeId = PyLong_FromUnsignedLongLong((uint32_t)(*r->out.pdwTypeId));
   33326          29 :         PyTuple_SetItem(result, 0, py_pdwTypeId);
   33327          29 :         py_ppData = pyrpc_import_union(&DNSSRV_RPC_UNION_Type, r->out.ppData, *r->out.pdwTypeId, r->out.ppData, "union DNSSRV_RPC_UNION");
   33328          29 :         if (py_ppData == NULL) {
   33329           0 :                 return NULL;
   33330             :         }
   33331          29 :         PyTuple_SetItem(result, 1, py_ppData);
   33332          29 :         if (!W_ERROR_IS_OK(r->out.result)) {
   33333           0 :                 PyErr_SetWERROR(r->out.result);
   33334           0 :                 return NULL;
   33335             :         }
   33336             : 
   33337          29 :         return result;
   33338             : }
   33339             : 
   33340             : 
   33341           0 : static PyObject *py_DnssrvComplexOperation2_in_get_dwClientVersion(PyObject *obj, void *closure)
   33342             : {
   33343           0 :         struct DnssrvComplexOperation2 *object = pytalloc_get_ptr(obj);
   33344           0 :         PyObject *py_dwClientVersion;
   33345           0 :         py_dwClientVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->in.dwClientVersion));
   33346           0 :         return py_dwClientVersion;
   33347             : }
   33348             : 
   33349           0 : static int py_DnssrvComplexOperation2_in_set_dwClientVersion(PyObject *py_obj, PyObject *value, void *closure)
   33350             : {
   33351           0 :         struct DnssrvComplexOperation2 *object = pytalloc_get_ptr(py_obj);
   33352           0 :         if (value == NULL) {
   33353           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.dwClientVersion");
   33354           0 :                 return -1;
   33355             :         }
   33356             :         {
   33357           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.dwClientVersion));
   33358           0 :                 if (PyLong_Check(value)) {
   33359           0 :                         unsigned long long test_var;
   33360           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   33361           0 :                         if (PyErr_Occurred() != NULL) {
   33362           0 :                                 return -1;
   33363             :                         }
   33364           0 :                         if (test_var > uint_max) {
   33365           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   33366             :                                   PyLong_Type.tp_name, uint_max, test_var);
   33367           0 :                                 return -1;
   33368             :                         }
   33369           0 :                         object->in.dwClientVersion = test_var;
   33370             :                 } else {
   33371           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   33372             :                           PyLong_Type.tp_name);
   33373           0 :                         return -1;
   33374             :                 }
   33375             :         }
   33376           0 :         return 0;
   33377             : }
   33378             : 
   33379           0 : static PyObject *py_DnssrvComplexOperation2_in_get_dwSettingFlags(PyObject *obj, void *closure)
   33380             : {
   33381           0 :         struct DnssrvComplexOperation2 *object = pytalloc_get_ptr(obj);
   33382           0 :         PyObject *py_dwSettingFlags;
   33383           0 :         py_dwSettingFlags = PyLong_FromUnsignedLongLong((uint32_t)(object->in.dwSettingFlags));
   33384           0 :         return py_dwSettingFlags;
   33385             : }
   33386             : 
   33387           0 : static int py_DnssrvComplexOperation2_in_set_dwSettingFlags(PyObject *py_obj, PyObject *value, void *closure)
   33388             : {
   33389           0 :         struct DnssrvComplexOperation2 *object = pytalloc_get_ptr(py_obj);
   33390           0 :         if (value == NULL) {
   33391           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.dwSettingFlags");
   33392           0 :                 return -1;
   33393             :         }
   33394             :         {
   33395           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.dwSettingFlags));
   33396           0 :                 if (PyLong_Check(value)) {
   33397           0 :                         unsigned long long test_var;
   33398           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   33399           0 :                         if (PyErr_Occurred() != NULL) {
   33400           0 :                                 return -1;
   33401             :                         }
   33402           0 :                         if (test_var > uint_max) {
   33403           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   33404             :                                   PyLong_Type.tp_name, uint_max, test_var);
   33405           0 :                                 return -1;
   33406             :                         }
   33407           0 :                         object->in.dwSettingFlags = test_var;
   33408             :                 } else {
   33409           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   33410             :                           PyLong_Type.tp_name);
   33411           0 :                         return -1;
   33412             :                 }
   33413             :         }
   33414           0 :         return 0;
   33415             : }
   33416             : 
   33417           0 : static PyObject *py_DnssrvComplexOperation2_in_get_pwszServerName(PyObject *obj, void *closure)
   33418             : {
   33419           0 :         struct DnssrvComplexOperation2 *object = pytalloc_get_ptr(obj);
   33420           0 :         PyObject *py_pwszServerName;
   33421           0 :         if (object->in.pwszServerName == NULL) {
   33422           0 :                 Py_RETURN_NONE;
   33423             :         }
   33424           0 :         if (object->in.pwszServerName == NULL) {
   33425           0 :                 py_pwszServerName = Py_None;
   33426           0 :                 Py_INCREF(py_pwszServerName);
   33427             :         } else {
   33428           0 :                 if (object->in.pwszServerName == NULL) {
   33429           0 :                         py_pwszServerName = Py_None;
   33430           0 :                         Py_INCREF(py_pwszServerName);
   33431             :                 } else {
   33432           0 :                         py_pwszServerName = PyUnicode_Decode(object->in.pwszServerName, strlen(object->in.pwszServerName), "utf-8", "ignore");
   33433             :                 }
   33434             :         }
   33435           0 :         return py_pwszServerName;
   33436             : }
   33437             : 
   33438           0 : static int py_DnssrvComplexOperation2_in_set_pwszServerName(PyObject *py_obj, PyObject *value, void *closure)
   33439             : {
   33440           0 :         struct DnssrvComplexOperation2 *object = pytalloc_get_ptr(py_obj);
   33441           0 :         if (value == NULL) {
   33442           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pwszServerName");
   33443           0 :                 return -1;
   33444             :         }
   33445           0 :         if (value == Py_None) {
   33446           0 :                 object->in.pwszServerName = NULL;
   33447             :         } else {
   33448           0 :                 object->in.pwszServerName = NULL;
   33449             :                 {
   33450           0 :                         const char *test_str;
   33451           0 :                         const char *talloc_str;
   33452           0 :                         PyObject *unicode = NULL;
   33453           0 :                         if (PyUnicode_Check(value)) {
   33454           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   33455           0 :                                 if (unicode == NULL) {
   33456           0 :                                         return -1;
   33457             :                                 }
   33458           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   33459           0 :                         } else if (PyBytes_Check(value)) {
   33460           0 :                                 test_str = PyBytes_AS_STRING(value);
   33461             :                         } else {
   33462           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   33463           0 :                                 return -1;
   33464             :                         }
   33465           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   33466           0 :                         if (unicode != NULL) {
   33467           0 :                                 Py_DECREF(unicode);
   33468             :                         }
   33469           0 :                         if (talloc_str == NULL) {
   33470           0 :                                 PyErr_NoMemory();
   33471           0 :                                 return -1;
   33472             :                         }
   33473           0 :                         object->in.pwszServerName = talloc_str;
   33474             :                 }
   33475             :         }
   33476           0 :         return 0;
   33477             : }
   33478             : 
   33479           0 : static PyObject *py_DnssrvComplexOperation2_in_get_pszZone(PyObject *obj, void *closure)
   33480             : {
   33481           0 :         struct DnssrvComplexOperation2 *object = pytalloc_get_ptr(obj);
   33482           0 :         PyObject *py_pszZone;
   33483           0 :         if (object->in.pszZone == NULL) {
   33484           0 :                 Py_RETURN_NONE;
   33485             :         }
   33486           0 :         if (object->in.pszZone == NULL) {
   33487           0 :                 py_pszZone = Py_None;
   33488           0 :                 Py_INCREF(py_pszZone);
   33489             :         } else {
   33490           0 :                 if (object->in.pszZone == NULL) {
   33491           0 :                         py_pszZone = Py_None;
   33492           0 :                         Py_INCREF(py_pszZone);
   33493             :                 } else {
   33494           0 :                         py_pszZone = PyUnicode_Decode(object->in.pszZone, strlen(object->in.pszZone), "utf-8", "ignore");
   33495             :                 }
   33496             :         }
   33497           0 :         return py_pszZone;
   33498             : }
   33499             : 
   33500           0 : static int py_DnssrvComplexOperation2_in_set_pszZone(PyObject *py_obj, PyObject *value, void *closure)
   33501             : {
   33502           0 :         struct DnssrvComplexOperation2 *object = pytalloc_get_ptr(py_obj);
   33503           0 :         if (value == NULL) {
   33504           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszZone");
   33505           0 :                 return -1;
   33506             :         }
   33507           0 :         if (value == Py_None) {
   33508           0 :                 object->in.pszZone = NULL;
   33509             :         } else {
   33510           0 :                 object->in.pszZone = NULL;
   33511             :                 {
   33512           0 :                         const char *test_str;
   33513           0 :                         const char *talloc_str;
   33514           0 :                         PyObject *unicode = NULL;
   33515           0 :                         if (PyUnicode_Check(value)) {
   33516           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   33517           0 :                                 if (unicode == NULL) {
   33518           0 :                                         return -1;
   33519             :                                 }
   33520           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   33521           0 :                         } else if (PyBytes_Check(value)) {
   33522           0 :                                 test_str = PyBytes_AS_STRING(value);
   33523             :                         } else {
   33524           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   33525           0 :                                 return -1;
   33526             :                         }
   33527           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   33528           0 :                         if (unicode != NULL) {
   33529           0 :                                 Py_DECREF(unicode);
   33530             :                         }
   33531           0 :                         if (talloc_str == NULL) {
   33532           0 :                                 PyErr_NoMemory();
   33533           0 :                                 return -1;
   33534             :                         }
   33535           0 :                         object->in.pszZone = talloc_str;
   33536             :                 }
   33537             :         }
   33538           0 :         return 0;
   33539             : }
   33540             : 
   33541           0 : static PyObject *py_DnssrvComplexOperation2_in_get_pszOperation(PyObject *obj, void *closure)
   33542             : {
   33543           0 :         struct DnssrvComplexOperation2 *object = pytalloc_get_ptr(obj);
   33544           0 :         PyObject *py_pszOperation;
   33545           0 :         if (object->in.pszOperation == NULL) {
   33546           0 :                 Py_RETURN_NONE;
   33547             :         }
   33548           0 :         if (object->in.pszOperation == NULL) {
   33549           0 :                 py_pszOperation = Py_None;
   33550           0 :                 Py_INCREF(py_pszOperation);
   33551             :         } else {
   33552           0 :                 if (object->in.pszOperation == NULL) {
   33553           0 :                         py_pszOperation = Py_None;
   33554           0 :                         Py_INCREF(py_pszOperation);
   33555             :                 } else {
   33556           0 :                         py_pszOperation = PyUnicode_Decode(object->in.pszOperation, strlen(object->in.pszOperation), "utf-8", "ignore");
   33557             :                 }
   33558             :         }
   33559           0 :         return py_pszOperation;
   33560             : }
   33561             : 
   33562           0 : static int py_DnssrvComplexOperation2_in_set_pszOperation(PyObject *py_obj, PyObject *value, void *closure)
   33563             : {
   33564           0 :         struct DnssrvComplexOperation2 *object = pytalloc_get_ptr(py_obj);
   33565           0 :         if (value == NULL) {
   33566           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszOperation");
   33567           0 :                 return -1;
   33568             :         }
   33569           0 :         if (value == Py_None) {
   33570           0 :                 object->in.pszOperation = NULL;
   33571             :         } else {
   33572           0 :                 object->in.pszOperation = NULL;
   33573             :                 {
   33574           0 :                         const char *test_str;
   33575           0 :                         const char *talloc_str;
   33576           0 :                         PyObject *unicode = NULL;
   33577           0 :                         if (PyUnicode_Check(value)) {
   33578           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   33579           0 :                                 if (unicode == NULL) {
   33580           0 :                                         return -1;
   33581             :                                 }
   33582           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   33583           0 :                         } else if (PyBytes_Check(value)) {
   33584           0 :                                 test_str = PyBytes_AS_STRING(value);
   33585             :                         } else {
   33586           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   33587           0 :                                 return -1;
   33588             :                         }
   33589           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   33590           0 :                         if (unicode != NULL) {
   33591           0 :                                 Py_DECREF(unicode);
   33592             :                         }
   33593           0 :                         if (talloc_str == NULL) {
   33594           0 :                                 PyErr_NoMemory();
   33595           0 :                                 return -1;
   33596             :                         }
   33597           0 :                         object->in.pszOperation = talloc_str;
   33598             :                 }
   33599             :         }
   33600           0 :         return 0;
   33601             : }
   33602             : 
   33603           0 : static PyObject *py_DnssrvComplexOperation2_in_get_dwTypeIn(PyObject *obj, void *closure)
   33604             : {
   33605           0 :         struct DnssrvComplexOperation2 *object = pytalloc_get_ptr(obj);
   33606           0 :         PyObject *py_dwTypeIn;
   33607           0 :         py_dwTypeIn = PyLong_FromUnsignedLongLong((uint32_t)(object->in.dwTypeIn));
   33608           0 :         return py_dwTypeIn;
   33609             : }
   33610             : 
   33611           0 : static int py_DnssrvComplexOperation2_in_set_dwTypeIn(PyObject *py_obj, PyObject *value, void *closure)
   33612             : {
   33613           0 :         struct DnssrvComplexOperation2 *object = pytalloc_get_ptr(py_obj);
   33614           0 :         if (value == NULL) {
   33615           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.dwTypeIn");
   33616           0 :                 return -1;
   33617             :         }
   33618             :         {
   33619           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.dwTypeIn));
   33620           0 :                 if (PyLong_Check(value)) {
   33621           0 :                         unsigned long long test_var;
   33622           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   33623           0 :                         if (PyErr_Occurred() != NULL) {
   33624           0 :                                 return -1;
   33625             :                         }
   33626           0 :                         if (test_var > uint_max) {
   33627           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   33628             :                                   PyLong_Type.tp_name, uint_max, test_var);
   33629           0 :                                 return -1;
   33630             :                         }
   33631           0 :                         object->in.dwTypeIn = test_var;
   33632             :                 } else {
   33633           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   33634             :                           PyLong_Type.tp_name);
   33635           0 :                         return -1;
   33636             :                 }
   33637             :         }
   33638           0 :         return 0;
   33639             : }
   33640             : 
   33641           0 : static PyObject *py_DnssrvComplexOperation2_in_get_pDataIn(PyObject *obj, void *closure)
   33642             : {
   33643           0 :         struct DnssrvComplexOperation2 *object = pytalloc_get_ptr(obj);
   33644           0 :         PyObject *py_pDataIn;
   33645           0 :         py_pDataIn = pyrpc_import_union(&DNSSRV_RPC_UNION_Type, pytalloc_get_mem_ctx(obj), object->in.dwTypeIn, &object->in.pDataIn, "union DNSSRV_RPC_UNION");
   33646           0 :         if (py_pDataIn == NULL) {
   33647           0 :                 return NULL;
   33648             :         }
   33649           0 :         return py_pDataIn;
   33650             : }
   33651             : 
   33652           0 : static int py_DnssrvComplexOperation2_in_set_pDataIn(PyObject *py_obj, PyObject *value, void *closure)
   33653             : {
   33654           0 :         struct DnssrvComplexOperation2 *object = pytalloc_get_ptr(py_obj);
   33655           0 :         if (value == NULL) {
   33656           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pDataIn");
   33657           0 :                 return -1;
   33658             :         }
   33659             :         {
   33660           0 :                 union DNSSRV_RPC_UNION *pDataIn_switch_0;
   33661           0 :                 pDataIn_switch_0 = (union DNSSRV_RPC_UNION *)pyrpc_export_union(&DNSSRV_RPC_UNION_Type, pytalloc_get_mem_ctx(py_obj), object->in.dwTypeIn, value, "union DNSSRV_RPC_UNION");
   33662           0 :                 if (pDataIn_switch_0 == NULL) {
   33663           0 :                         return -1;
   33664             :                 }
   33665           0 :                 object->in.pDataIn = *pDataIn_switch_0;
   33666             :         }
   33667           0 :         return 0;
   33668             : }
   33669             : 
   33670           0 : static PyObject *py_DnssrvComplexOperation2_out_get_pdwTypeOut(PyObject *obj, void *closure)
   33671             : {
   33672           0 :         struct DnssrvComplexOperation2 *object = pytalloc_get_ptr(obj);
   33673           0 :         PyObject *py_pdwTypeOut;
   33674           0 :         if (object->out.pdwTypeOut == NULL) {
   33675           0 :                 Py_RETURN_NONE;
   33676             :         }
   33677           0 :         py_pdwTypeOut = PyLong_FromUnsignedLongLong((uint32_t)(*object->out.pdwTypeOut));
   33678           0 :         return py_pdwTypeOut;
   33679             : }
   33680             : 
   33681           0 : static int py_DnssrvComplexOperation2_out_set_pdwTypeOut(PyObject *py_obj, PyObject *value, void *closure)
   33682             : {
   33683           0 :         struct DnssrvComplexOperation2 *object = pytalloc_get_ptr(py_obj);
   33684           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.pdwTypeOut));
   33685           0 :         if (value == NULL) {
   33686           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.pdwTypeOut");
   33687           0 :                 return -1;
   33688             :         }
   33689           0 :         object->out.pdwTypeOut = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.pdwTypeOut);
   33690           0 :         if (object->out.pdwTypeOut == NULL) {
   33691           0 :                 PyErr_NoMemory();
   33692           0 :                 return -1;
   33693             :         }
   33694             :         {
   33695           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->out.pdwTypeOut));
   33696           0 :                 if (PyLong_Check(value)) {
   33697           0 :                         unsigned long long test_var;
   33698           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   33699           0 :                         if (PyErr_Occurred() != NULL) {
   33700           0 :                                 return -1;
   33701             :                         }
   33702           0 :                         if (test_var > uint_max) {
   33703           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   33704             :                                   PyLong_Type.tp_name, uint_max, test_var);
   33705           0 :                                 return -1;
   33706             :                         }
   33707           0 :                         *object->out.pdwTypeOut = test_var;
   33708             :                 } else {
   33709           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   33710             :                           PyLong_Type.tp_name);
   33711           0 :                         return -1;
   33712             :                 }
   33713             :         }
   33714           0 :         return 0;
   33715             : }
   33716             : 
   33717           0 : static PyObject *py_DnssrvComplexOperation2_out_get_ppDataOut(PyObject *obj, void *closure)
   33718             : {
   33719           0 :         struct DnssrvComplexOperation2 *object = pytalloc_get_ptr(obj);
   33720           0 :         PyObject *py_ppDataOut;
   33721           0 :         if (object->out.ppDataOut == NULL) {
   33722           0 :                 Py_RETURN_NONE;
   33723             :         }
   33724           0 :         py_ppDataOut = pyrpc_import_union(&DNSSRV_RPC_UNION_Type, object->out.ppDataOut, *object->out.pdwTypeOut, object->out.ppDataOut, "union DNSSRV_RPC_UNION");
   33725           0 :         if (py_ppDataOut == NULL) {
   33726           0 :                 return NULL;
   33727             :         }
   33728           0 :         return py_ppDataOut;
   33729             : }
   33730             : 
   33731           0 : static int py_DnssrvComplexOperation2_out_set_ppDataOut(PyObject *py_obj, PyObject *value, void *closure)
   33732             : {
   33733           0 :         struct DnssrvComplexOperation2 *object = pytalloc_get_ptr(py_obj);
   33734           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.ppDataOut));
   33735           0 :         if (value == NULL) {
   33736           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.ppDataOut");
   33737           0 :                 return -1;
   33738             :         }
   33739           0 :         object->out.ppDataOut = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.ppDataOut);
   33740           0 :         if (object->out.ppDataOut == NULL) {
   33741           0 :                 PyErr_NoMemory();
   33742           0 :                 return -1;
   33743             :         }
   33744             :         {
   33745           0 :                 union DNSSRV_RPC_UNION *ppDataOut_switch_1;
   33746           0 :                 ppDataOut_switch_1 = (union DNSSRV_RPC_UNION *)pyrpc_export_union(&DNSSRV_RPC_UNION_Type, pytalloc_get_mem_ctx(py_obj), *object->out.pdwTypeOut, value, "union DNSSRV_RPC_UNION");
   33747           0 :                 if (ppDataOut_switch_1 == NULL) {
   33748           0 :                         return -1;
   33749             :                 }
   33750           0 :                 object->out.ppDataOut = ppDataOut_switch_1;
   33751             :         }
   33752           0 :         return 0;
   33753             : }
   33754             : 
   33755           0 : static PyObject *py_DnssrvComplexOperation2_get_result(PyObject *obj, void *closure)
   33756             : {
   33757           0 :         struct DnssrvComplexOperation2 *object = pytalloc_get_ptr(obj);
   33758           0 :         PyObject *py_result;
   33759           0 :         py_result = PyErr_FromWERROR(object->out.result);
   33760           0 :         return py_result;
   33761             : }
   33762             : 
   33763           0 : static int py_DnssrvComplexOperation2_set_result(PyObject *py_obj, PyObject *value, void *closure)
   33764             : {
   33765           0 :         struct DnssrvComplexOperation2 *object = pytalloc_get_ptr(py_obj);
   33766           0 :         if (value == NULL) {
   33767           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.result");
   33768           0 :                 return -1;
   33769             :         }
   33770           0 :         object->out.result = W_ERROR(PyLong_AsLong(value));
   33771           0 :         return 0;
   33772             : }
   33773             : 
   33774             : static PyGetSetDef py_DnssrvComplexOperation2_getsetters[] = {
   33775             :         {
   33776             :                 .name = discard_const_p(char, "in_dwClientVersion"),
   33777             :                 .get = py_DnssrvComplexOperation2_in_get_dwClientVersion,
   33778             :                 .set = py_DnssrvComplexOperation2_in_set_dwClientVersion,
   33779             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_CLIENT_VERSION")
   33780             :         },
   33781             :         {
   33782             :                 .name = discard_const_p(char, "in_dwSettingFlags"),
   33783             :                 .get = py_DnssrvComplexOperation2_in_get_dwSettingFlags,
   33784             :                 .set = py_DnssrvComplexOperation2_in_set_dwSettingFlags,
   33785             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   33786             :         },
   33787             :         {
   33788             :                 .name = discard_const_p(char, "in_pwszServerName"),
   33789             :                 .get = py_DnssrvComplexOperation2_in_get_pwszServerName,
   33790             :                 .set = py_DnssrvComplexOperation2_in_set_pwszServerName,
   33791             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
   33792             :         },
   33793             :         {
   33794             :                 .name = discard_const_p(char, "in_pszZone"),
   33795             :                 .get = py_DnssrvComplexOperation2_in_get_pszZone,
   33796             :                 .set = py_DnssrvComplexOperation2_in_set_pszZone,
   33797             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   33798             :         },
   33799             :         {
   33800             :                 .name = discard_const_p(char, "in_pszOperation"),
   33801             :                 .get = py_DnssrvComplexOperation2_in_get_pszOperation,
   33802             :                 .set = py_DnssrvComplexOperation2_in_set_pszOperation,
   33803             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   33804             :         },
   33805             :         {
   33806             :                 .name = discard_const_p(char, "in_dwTypeIn"),
   33807             :                 .get = py_DnssrvComplexOperation2_in_get_dwTypeIn,
   33808             :                 .set = py_DnssrvComplexOperation2_in_set_dwTypeIn,
   33809             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_TYPEID")
   33810             :         },
   33811             :         {
   33812             :                 .name = discard_const_p(char, "in_pDataIn"),
   33813             :                 .get = py_DnssrvComplexOperation2_in_get_pDataIn,
   33814             :                 .set = py_DnssrvComplexOperation2_in_set_pDataIn,
   33815             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNSSRV_RPC_UNION")
   33816             :         },
   33817             :         {
   33818             :                 .name = discard_const_p(char, "out_pdwTypeOut"),
   33819             :                 .get = py_DnssrvComplexOperation2_out_get_pdwTypeOut,
   33820             :                 .set = py_DnssrvComplexOperation2_out_set_pdwTypeOut,
   33821             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_TYPEID")
   33822             :         },
   33823             :         {
   33824             :                 .name = discard_const_p(char, "out_ppDataOut"),
   33825             :                 .get = py_DnssrvComplexOperation2_out_get_ppDataOut,
   33826             :                 .set = py_DnssrvComplexOperation2_out_set_ppDataOut,
   33827             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNSSRV_RPC_UNION")
   33828             :         },
   33829             :         {
   33830             :                 .name = discard_const_p(char, "result"),
   33831             :                 .get = py_DnssrvComplexOperation2_get_result,
   33832             :                 .set = py_DnssrvComplexOperation2_set_result,
   33833             :                 .doc = discard_const_p(char, "PIDL-generated element of type WERROR")
   33834             :         },
   33835             :         { .name = NULL }
   33836             : };
   33837             : 
   33838           0 : static PyObject *py_DnssrvComplexOperation2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   33839             : {
   33840           0 :         PyObject *self = pytalloc_new(struct DnssrvComplexOperation2, type);
   33841           0 :         struct DnssrvComplexOperation2 *_self = (struct DnssrvComplexOperation2 *)pytalloc_get_ptr(self);
   33842           0 :         TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
   33843           0 :         _self->out.pdwTypeOut = talloc_zero(mem_ctx, enum DNS_RPC_TYPEID);
   33844           0 :         _self->out.ppDataOut = talloc_zero(mem_ctx, union DNSSRV_RPC_UNION);
   33845           0 :         return self;
   33846             : }
   33847             : 
   33848           0 : static PyObject *py_DnssrvComplexOperation2_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
   33849             : {
   33850             : 
   33851             : 
   33852           0 :         return PyLong_FromLong(7);
   33853             : }
   33854             : 
   33855           0 : static PyObject *py_DnssrvComplexOperation2_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
   33856             : {
   33857           0 :         const struct ndr_interface_call *call = NULL;
   33858           0 :         struct DnssrvComplexOperation2 *object = pytalloc_get_ptr(py_obj);
   33859           0 :         PyObject *ret = NULL;
   33860           0 :         struct ndr_push *push = NULL;
   33861           0 :         DATA_BLOB blob;
   33862           0 :         enum ndr_err_code err;
   33863             : 
   33864           0 :         if (ndr_table_dnsserver.num_calls < 8) {
   33865           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvComplexOperation2_ndr_pack");
   33866           0 :                 return NULL;
   33867             :         }
   33868           0 :         call = &ndr_table_dnsserver.calls[7];
   33869             : 
   33870           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
   33871           0 :         if (push == NULL) {
   33872           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
   33873           0 :                 return NULL;
   33874             :         }
   33875             : 
   33876           0 :         push->flags |= ndr_push_flags;
   33877             : 
   33878           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
   33879           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   33880           0 :                 TALLOC_FREE(push);
   33881           0 :                 PyErr_SetNdrError(err);
   33882           0 :                 return NULL;
   33883             :         }
   33884           0 :         blob = ndr_push_blob(push);
   33885           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
   33886           0 :         TALLOC_FREE(push);
   33887           0 :         return ret;
   33888             : }
   33889             : 
   33890           0 : static PyObject *py_DnssrvComplexOperation2_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   33891             : {
   33892           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
   33893           0 :         PyObject *bigendian_obj = NULL;
   33894           0 :         PyObject *ndr64_obj = NULL;
   33895           0 :         libndr_flags ndr_push_flags = 0;
   33896             : 
   33897           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
   33898             :                 discard_const_p(char *, kwnames),
   33899             :                 &bigendian_obj,
   33900             :                 &ndr64_obj)) {
   33901           0 :                 return NULL;
   33902             :         }
   33903             : 
   33904           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   33905           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
   33906             :         }
   33907           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   33908           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
   33909             :         }
   33910             : 
   33911           0 :         return py_DnssrvComplexOperation2_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
   33912             : }
   33913             : 
   33914           0 : static PyObject *py_DnssrvComplexOperation2_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   33915             : {
   33916           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
   33917           0 :         PyObject *bigendian_obj = NULL;
   33918           0 :         PyObject *ndr64_obj = NULL;
   33919           0 :         libndr_flags ndr_push_flags = 0;
   33920             : 
   33921           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
   33922             :                 discard_const_p(char *, kwnames),
   33923             :                 &bigendian_obj,
   33924             :                 &ndr64_obj)) {
   33925           0 :                 return NULL;
   33926             :         }
   33927             : 
   33928           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   33929           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
   33930             :         }
   33931           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   33932           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
   33933             :         }
   33934             : 
   33935           0 :         return py_DnssrvComplexOperation2_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
   33936             : }
   33937             : 
   33938           0 : static PyObject *py_DnssrvComplexOperation2_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
   33939             : {
   33940           0 :         const struct ndr_interface_call *call = NULL;
   33941           0 :         struct DnssrvComplexOperation2 *object = pytalloc_get_ptr(py_obj);
   33942           0 :         struct ndr_pull *pull = NULL;
   33943           0 :         enum ndr_err_code err;
   33944             : 
   33945           0 :         if (ndr_table_dnsserver.num_calls < 8) {
   33946           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvComplexOperation2_ndr_unpack");
   33947           0 :                 return NULL;
   33948             :         }
   33949           0 :         call = &ndr_table_dnsserver.calls[7];
   33950             : 
   33951           0 :         pull = ndr_pull_init_blob(blob, object);
   33952           0 :         if (pull == NULL) {
   33953           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
   33954           0 :                 return NULL;
   33955             :         }
   33956             : 
   33957           0 :         pull->flags |= ndr_pull_flags;
   33958             : 
   33959           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
   33960           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   33961           0 :                 TALLOC_FREE(pull);
   33962           0 :                 PyErr_SetNdrError(err);
   33963           0 :                 return NULL;
   33964             :         }
   33965           0 :         if (!allow_remaining) {
   33966           0 :                 uint32_t highest_ofs;
   33967             : 
   33968           0 :                 if (pull->offset > pull->relative_highest_offset) {
   33969           0 :                         highest_ofs = pull->offset;
   33970             :                 } else {
   33971           0 :                         highest_ofs = pull->relative_highest_offset;
   33972             :                 }
   33973           0 :                 if (highest_ofs < pull->data_size) {
   33974           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
   33975             :                                 "not all bytes consumed ofs[%u] size[%u]",
   33976             :                                 highest_ofs, pull->data_size);
   33977           0 :                         TALLOC_FREE(pull);
   33978           0 :                         PyErr_SetNdrError(err);
   33979           0 :                         return NULL;
   33980             :                 }
   33981             :         }
   33982             : 
   33983           0 :         TALLOC_FREE(pull);
   33984           0 :         Py_RETURN_NONE;
   33985             : }
   33986             : 
   33987           0 : static PyObject *py_DnssrvComplexOperation2_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   33988             : {
   33989           0 :         DATA_BLOB blob;
   33990           0 :         Py_ssize_t blob_length = 0;
   33991           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
   33992           0 :         PyObject *bigendian_obj = NULL;
   33993           0 :         PyObject *ndr64_obj = NULL;
   33994           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
   33995           0 :         PyObject *allow_remaining_obj = NULL;
   33996           0 :         bool allow_remaining = false;
   33997             : 
   33998           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
   33999             :                 discard_const_p(char *, kwnames),
   34000             :                 &blob.data, &blob_length,
   34001             :                 &bigendian_obj,
   34002             :                 &ndr64_obj,
   34003             :                 &allow_remaining_obj)) {
   34004           0 :                 return NULL;
   34005             :         }
   34006           0 :         blob.length = blob_length;
   34007             : 
   34008           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   34009           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
   34010             :         }
   34011           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   34012           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
   34013             :         }
   34014             : 
   34015           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
   34016           0 :                 allow_remaining = true;
   34017             :         }
   34018             : 
   34019           0 :         return py_DnssrvComplexOperation2_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
   34020             : }
   34021             : 
   34022           0 : static PyObject *py_DnssrvComplexOperation2_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   34023             : {
   34024           0 :         DATA_BLOB blob;
   34025           0 :         Py_ssize_t blob_length = 0;
   34026           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
   34027           0 :         PyObject *bigendian_obj = NULL;
   34028           0 :         PyObject *ndr64_obj = NULL;
   34029           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
   34030           0 :         PyObject *allow_remaining_obj = NULL;
   34031           0 :         bool allow_remaining = false;
   34032             : 
   34033           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
   34034             :                 discard_const_p(char *, kwnames),
   34035             :                 &blob.data, &blob_length,
   34036             :                 &bigendian_obj,
   34037             :                 &ndr64_obj,
   34038             :                 &allow_remaining_obj)) {
   34039           0 :                 return NULL;
   34040             :         }
   34041           0 :         blob.length = blob_length;
   34042             : 
   34043           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   34044           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
   34045             :         }
   34046           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   34047           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
   34048             :         }
   34049             : 
   34050           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
   34051           0 :                 allow_remaining = true;
   34052             :         }
   34053             : 
   34054           0 :         return py_DnssrvComplexOperation2_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
   34055             : }
   34056             : 
   34057           0 : static PyObject *py_DnssrvComplexOperation2_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
   34058             : {
   34059           0 :         const struct ndr_interface_call *call = NULL;
   34060           0 :         struct DnssrvComplexOperation2 *object = pytalloc_get_ptr(py_obj);
   34061           0 :         PyObject *ret;
   34062           0 :         char *retstr;
   34063             : 
   34064           0 :         if (ndr_table_dnsserver.num_calls < 8) {
   34065           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvComplexOperation2_ndr_print");
   34066           0 :                 return NULL;
   34067             :         }
   34068           0 :         call = &ndr_table_dnsserver.calls[7];
   34069             : 
   34070           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
   34071           0 :         ret = PyUnicode_FromString(retstr);
   34072           0 :         TALLOC_FREE(retstr);
   34073             : 
   34074           0 :         return ret;
   34075             : }
   34076             : 
   34077           0 : static PyObject *py_DnssrvComplexOperation2_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
   34078             : {
   34079           0 :         return py_DnssrvComplexOperation2_ndr_print(py_obj, "DnssrvComplexOperation2_in", NDR_IN);
   34080             : }
   34081             : 
   34082           0 : static PyObject *py_DnssrvComplexOperation2_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
   34083             : {
   34084           0 :         return py_DnssrvComplexOperation2_ndr_print(py_obj, "DnssrvComplexOperation2_out", NDR_OUT);
   34085             : }
   34086             : 
   34087             : static PyMethodDef py_DnssrvComplexOperation2_methods[] = {
   34088             :         { "opnum", (PyCFunction)py_DnssrvComplexOperation2_ndr_opnum, METH_NOARGS|METH_CLASS,
   34089             :                 "dnsserver.DnssrvComplexOperation2.opnum() -> 7 (0x07) " },
   34090             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvComplexOperation2_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
   34091             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
   34092             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvComplexOperation2_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
   34093             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
   34094             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvComplexOperation2_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
   34095             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
   34096             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvComplexOperation2_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
   34097             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
   34098             :         { "__ndr_print_in__", (PyCFunction)py_DnssrvComplexOperation2_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
   34099             :         { "__ndr_print_out__", (PyCFunction)py_DnssrvComplexOperation2_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
   34100             :         { NULL, NULL, 0, NULL }
   34101             : };
   34102             : 
   34103             : 
   34104             : static PyTypeObject DnssrvComplexOperation2_Type = {
   34105             :         PyVarObject_HEAD_INIT(NULL, 0)
   34106             :         .tp_name = "dnsserver.DnssrvComplexOperation2",
   34107             :         .tp_getset = py_DnssrvComplexOperation2_getsetters,
   34108             :         .tp_methods = py_DnssrvComplexOperation2_methods,
   34109             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   34110             :         .tp_new = py_DnssrvComplexOperation2_new,
   34111             : };
   34112             : 
   34113          20 : static bool pack_py_DnssrvComplexOperation2_args_in(PyObject *args, PyObject *kwargs, struct DnssrvComplexOperation2 *r)
   34114             : {
   34115           0 :         PyObject *py_dwClientVersion;
   34116           0 :         PyObject *py_dwSettingFlags;
   34117           0 :         PyObject *py_pwszServerName;
   34118           0 :         PyObject *py_pszZone;
   34119           0 :         PyObject *py_pszOperation;
   34120           0 :         PyObject *py_dwTypeIn;
   34121           0 :         PyObject *py_pDataIn;
   34122          20 :         const char *kwnames[] = {
   34123             :                 "dwClientVersion", "dwSettingFlags", "pwszServerName", "pszZone", "pszOperation", "dwTypeIn", "pDataIn", NULL
   34124             :         };
   34125             : 
   34126          20 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOO:DnssrvComplexOperation2", discard_const_p(char *, kwnames), &py_dwClientVersion, &py_dwSettingFlags, &py_pwszServerName, &py_pszZone, &py_pszOperation, &py_dwTypeIn, &py_pDataIn)) {
   34127           0 :                 return false;
   34128             :         }
   34129             : 
   34130          20 :         if (py_dwClientVersion == NULL) {
   34131           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.dwClientVersion");
   34132           0 :                 return false;
   34133             :         }
   34134             :         {
   34135          20 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.dwClientVersion));
   34136          20 :                 if (PyLong_Check(py_dwClientVersion)) {
   34137           0 :                         unsigned long long test_var;
   34138          20 :                         test_var = PyLong_AsUnsignedLongLong(py_dwClientVersion);
   34139          20 :                         if (PyErr_Occurred() != NULL) {
   34140           0 :                                 return false;
   34141             :                         }
   34142          20 :                         if (test_var > uint_max) {
   34143           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   34144             :                                   PyLong_Type.tp_name, uint_max, test_var);
   34145           0 :                                 return false;
   34146             :                         }
   34147          20 :                         r->in.dwClientVersion = test_var;
   34148             :                 } else {
   34149           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   34150             :                           PyLong_Type.tp_name);
   34151           0 :                         return false;
   34152             :                 }
   34153             :         }
   34154          20 :         if (py_dwSettingFlags == NULL) {
   34155           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.dwSettingFlags");
   34156           0 :                 return false;
   34157             :         }
   34158             :         {
   34159          20 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.dwSettingFlags));
   34160          20 :                 if (PyLong_Check(py_dwSettingFlags)) {
   34161           0 :                         unsigned long long test_var;
   34162          20 :                         test_var = PyLong_AsUnsignedLongLong(py_dwSettingFlags);
   34163          20 :                         if (PyErr_Occurred() != NULL) {
   34164           0 :                                 return false;
   34165             :                         }
   34166          20 :                         if (test_var > uint_max) {
   34167           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   34168             :                                   PyLong_Type.tp_name, uint_max, test_var);
   34169           0 :                                 return false;
   34170             :                         }
   34171          20 :                         r->in.dwSettingFlags = test_var;
   34172             :                 } else {
   34173           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   34174             :                           PyLong_Type.tp_name);
   34175           0 :                         return false;
   34176             :                 }
   34177             :         }
   34178          20 :         if (py_pwszServerName == NULL) {
   34179           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pwszServerName");
   34180           0 :                 return false;
   34181             :         }
   34182          20 :         if (py_pwszServerName == Py_None) {
   34183           0 :                 r->in.pwszServerName = NULL;
   34184             :         } else {
   34185          20 :                 r->in.pwszServerName = NULL;
   34186             :                 {
   34187           0 :                         const char *test_str;
   34188           0 :                         const char *talloc_str;
   34189          20 :                         PyObject *unicode = NULL;
   34190          20 :                         if (PyUnicode_Check(py_pwszServerName)) {
   34191          20 :                                 unicode = PyUnicode_AsEncodedString(py_pwszServerName, "utf-8", "ignore");
   34192          20 :                                 if (unicode == NULL) {
   34193           0 :                                         return false;
   34194             :                                 }
   34195          20 :                                 test_str = PyBytes_AS_STRING(unicode);
   34196           0 :                         } else if (PyBytes_Check(py_pwszServerName)) {
   34197           0 :                                 test_str = PyBytes_AS_STRING(py_pwszServerName);
   34198             :                         } else {
   34199           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pwszServerName)->tp_name);
   34200           0 :                                 return false;
   34201             :                         }
   34202          20 :                         talloc_str = talloc_strdup(r, test_str);
   34203          20 :                         if (unicode != NULL) {
   34204          14 :                                 Py_DECREF(unicode);
   34205             :                         }
   34206          20 :                         if (talloc_str == NULL) {
   34207           0 :                                 PyErr_NoMemory();
   34208           0 :                                 return false;
   34209             :                         }
   34210          20 :                         r->in.pwszServerName = talloc_str;
   34211             :                 }
   34212             :         }
   34213          20 :         if (py_pszZone == NULL) {
   34214           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszZone");
   34215           0 :                 return false;
   34216             :         }
   34217          20 :         if (py_pszZone == Py_None) {
   34218          20 :                 r->in.pszZone = NULL;
   34219             :         } else {
   34220           0 :                 r->in.pszZone = NULL;
   34221             :                 {
   34222           0 :                         const char *test_str;
   34223           0 :                         const char *talloc_str;
   34224           0 :                         PyObject *unicode = NULL;
   34225           0 :                         if (PyUnicode_Check(py_pszZone)) {
   34226           0 :                                 unicode = PyUnicode_AsEncodedString(py_pszZone, "utf-8", "ignore");
   34227           0 :                                 if (unicode == NULL) {
   34228           0 :                                         return false;
   34229             :                                 }
   34230           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   34231           0 :                         } else if (PyBytes_Check(py_pszZone)) {
   34232           0 :                                 test_str = PyBytes_AS_STRING(py_pszZone);
   34233             :                         } else {
   34234           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszZone)->tp_name);
   34235           0 :                                 return false;
   34236             :                         }
   34237           0 :                         talloc_str = talloc_strdup(r, test_str);
   34238           0 :                         if (unicode != NULL) {
   34239           0 :                                 Py_DECREF(unicode);
   34240             :                         }
   34241           0 :                         if (talloc_str == NULL) {
   34242           0 :                                 PyErr_NoMemory();
   34243           0 :                                 return false;
   34244             :                         }
   34245           0 :                         r->in.pszZone = talloc_str;
   34246             :                 }
   34247             :         }
   34248          20 :         if (py_pszOperation == NULL) {
   34249           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszOperation");
   34250           0 :                 return false;
   34251             :         }
   34252          20 :         if (py_pszOperation == Py_None) {
   34253           0 :                 r->in.pszOperation = NULL;
   34254             :         } else {
   34255          20 :                 r->in.pszOperation = NULL;
   34256             :                 {
   34257           0 :                         const char *test_str;
   34258           0 :                         const char *talloc_str;
   34259          20 :                         PyObject *unicode = NULL;
   34260          20 :                         if (PyUnicode_Check(py_pszOperation)) {
   34261          20 :                                 unicode = PyUnicode_AsEncodedString(py_pszOperation, "utf-8", "ignore");
   34262          20 :                                 if (unicode == NULL) {
   34263           0 :                                         return false;
   34264             :                                 }
   34265          20 :                                 test_str = PyBytes_AS_STRING(unicode);
   34266           0 :                         } else if (PyBytes_Check(py_pszOperation)) {
   34267           0 :                                 test_str = PyBytes_AS_STRING(py_pszOperation);
   34268             :                         } else {
   34269           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszOperation)->tp_name);
   34270           0 :                                 return false;
   34271             :                         }
   34272          20 :                         talloc_str = talloc_strdup(r, test_str);
   34273          20 :                         if (unicode != NULL) {
   34274          14 :                                 Py_DECREF(unicode);
   34275             :                         }
   34276          20 :                         if (talloc_str == NULL) {
   34277           0 :                                 PyErr_NoMemory();
   34278           0 :                                 return false;
   34279             :                         }
   34280          20 :                         r->in.pszOperation = talloc_str;
   34281             :                 }
   34282             :         }
   34283          20 :         if (py_dwTypeIn == NULL) {
   34284           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.dwTypeIn");
   34285           0 :                 return false;
   34286             :         }
   34287             :         {
   34288          20 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.dwTypeIn));
   34289          20 :                 if (PyLong_Check(py_dwTypeIn)) {
   34290           0 :                         unsigned long long test_var;
   34291          20 :                         test_var = PyLong_AsUnsignedLongLong(py_dwTypeIn);
   34292          20 :                         if (PyErr_Occurred() != NULL) {
   34293           0 :                                 return false;
   34294             :                         }
   34295          20 :                         if (test_var > uint_max) {
   34296           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   34297             :                                   PyLong_Type.tp_name, uint_max, test_var);
   34298           0 :                                 return false;
   34299             :                         }
   34300          20 :                         r->in.dwTypeIn = test_var;
   34301             :                 } else {
   34302           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   34303             :                           PyLong_Type.tp_name);
   34304           0 :                         return false;
   34305             :                 }
   34306             :         }
   34307          20 :         if (py_pDataIn == NULL) {
   34308           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pDataIn");
   34309           0 :                 return false;
   34310             :         }
   34311             :         {
   34312           0 :                 union DNSSRV_RPC_UNION *pDataIn_switch_0;
   34313          20 :                 pDataIn_switch_0 = (union DNSSRV_RPC_UNION *)pyrpc_export_union(&DNSSRV_RPC_UNION_Type, r, r->in.dwTypeIn, py_pDataIn, "union DNSSRV_RPC_UNION");
   34314          20 :                 if (pDataIn_switch_0 == NULL) {
   34315           0 :                         return false;
   34316             :                 }
   34317          20 :                 r->in.pDataIn = *pDataIn_switch_0;
   34318             :         }
   34319          20 :         return true;
   34320             : }
   34321             : 
   34322          20 : static PyObject *unpack_py_DnssrvComplexOperation2_args_out(struct DnssrvComplexOperation2 *r)
   34323             : {
   34324           0 :         PyObject *result;
   34325           0 :         PyObject *py_pdwTypeOut;
   34326           0 :         PyObject *py_ppDataOut;
   34327          20 :         result = PyTuple_New(2);
   34328          20 :         py_pdwTypeOut = PyLong_FromUnsignedLongLong((uint32_t)(*r->out.pdwTypeOut));
   34329          20 :         PyTuple_SetItem(result, 0, py_pdwTypeOut);
   34330          20 :         py_ppDataOut = pyrpc_import_union(&DNSSRV_RPC_UNION_Type, r->out.ppDataOut, *r->out.pdwTypeOut, r->out.ppDataOut, "union DNSSRV_RPC_UNION");
   34331          20 :         if (py_ppDataOut == NULL) {
   34332           0 :                 return NULL;
   34333             :         }
   34334          20 :         PyTuple_SetItem(result, 1, py_ppDataOut);
   34335          20 :         if (!W_ERROR_IS_OK(r->out.result)) {
   34336           0 :                 PyErr_SetWERROR(r->out.result);
   34337           0 :                 return NULL;
   34338             :         }
   34339             : 
   34340          20 :         return result;
   34341             : }
   34342             : 
   34343             : 
   34344           0 : static PyObject *py_DnssrvEnumRecords2_in_get_dwClientVersion(PyObject *obj, void *closure)
   34345             : {
   34346           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(obj);
   34347           0 :         PyObject *py_dwClientVersion;
   34348           0 :         py_dwClientVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->in.dwClientVersion));
   34349           0 :         return py_dwClientVersion;
   34350             : }
   34351             : 
   34352           0 : static int py_DnssrvEnumRecords2_in_set_dwClientVersion(PyObject *py_obj, PyObject *value, void *closure)
   34353             : {
   34354           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(py_obj);
   34355           0 :         if (value == NULL) {
   34356           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.dwClientVersion");
   34357           0 :                 return -1;
   34358             :         }
   34359             :         {
   34360           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.dwClientVersion));
   34361           0 :                 if (PyLong_Check(value)) {
   34362           0 :                         unsigned long long test_var;
   34363           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   34364           0 :                         if (PyErr_Occurred() != NULL) {
   34365           0 :                                 return -1;
   34366             :                         }
   34367           0 :                         if (test_var > uint_max) {
   34368           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   34369             :                                   PyLong_Type.tp_name, uint_max, test_var);
   34370           0 :                                 return -1;
   34371             :                         }
   34372           0 :                         object->in.dwClientVersion = test_var;
   34373             :                 } else {
   34374           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   34375             :                           PyLong_Type.tp_name);
   34376           0 :                         return -1;
   34377             :                 }
   34378             :         }
   34379           0 :         return 0;
   34380             : }
   34381             : 
   34382           0 : static PyObject *py_DnssrvEnumRecords2_in_get_dwSettingFlags(PyObject *obj, void *closure)
   34383             : {
   34384           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(obj);
   34385           0 :         PyObject *py_dwSettingFlags;
   34386           0 :         py_dwSettingFlags = PyLong_FromUnsignedLongLong((uint32_t)(object->in.dwSettingFlags));
   34387           0 :         return py_dwSettingFlags;
   34388             : }
   34389             : 
   34390           0 : static int py_DnssrvEnumRecords2_in_set_dwSettingFlags(PyObject *py_obj, PyObject *value, void *closure)
   34391             : {
   34392           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(py_obj);
   34393           0 :         if (value == NULL) {
   34394           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.dwSettingFlags");
   34395           0 :                 return -1;
   34396             :         }
   34397             :         {
   34398           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.dwSettingFlags));
   34399           0 :                 if (PyLong_Check(value)) {
   34400           0 :                         unsigned long long test_var;
   34401           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   34402           0 :                         if (PyErr_Occurred() != NULL) {
   34403           0 :                                 return -1;
   34404             :                         }
   34405           0 :                         if (test_var > uint_max) {
   34406           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   34407             :                                   PyLong_Type.tp_name, uint_max, test_var);
   34408           0 :                                 return -1;
   34409             :                         }
   34410           0 :                         object->in.dwSettingFlags = test_var;
   34411             :                 } else {
   34412           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   34413             :                           PyLong_Type.tp_name);
   34414           0 :                         return -1;
   34415             :                 }
   34416             :         }
   34417           0 :         return 0;
   34418             : }
   34419             : 
   34420           0 : static PyObject *py_DnssrvEnumRecords2_in_get_pwszServerName(PyObject *obj, void *closure)
   34421             : {
   34422           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(obj);
   34423           0 :         PyObject *py_pwszServerName;
   34424           0 :         if (object->in.pwszServerName == NULL) {
   34425           0 :                 Py_RETURN_NONE;
   34426             :         }
   34427           0 :         if (object->in.pwszServerName == NULL) {
   34428           0 :                 py_pwszServerName = Py_None;
   34429           0 :                 Py_INCREF(py_pwszServerName);
   34430             :         } else {
   34431           0 :                 if (object->in.pwszServerName == NULL) {
   34432           0 :                         py_pwszServerName = Py_None;
   34433           0 :                         Py_INCREF(py_pwszServerName);
   34434             :                 } else {
   34435           0 :                         py_pwszServerName = PyUnicode_Decode(object->in.pwszServerName, strlen(object->in.pwszServerName), "utf-8", "ignore");
   34436             :                 }
   34437             :         }
   34438           0 :         return py_pwszServerName;
   34439             : }
   34440             : 
   34441           0 : static int py_DnssrvEnumRecords2_in_set_pwszServerName(PyObject *py_obj, PyObject *value, void *closure)
   34442             : {
   34443           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(py_obj);
   34444           0 :         if (value == NULL) {
   34445           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pwszServerName");
   34446           0 :                 return -1;
   34447             :         }
   34448           0 :         if (value == Py_None) {
   34449           0 :                 object->in.pwszServerName = NULL;
   34450             :         } else {
   34451           0 :                 object->in.pwszServerName = NULL;
   34452             :                 {
   34453           0 :                         const char *test_str;
   34454           0 :                         const char *talloc_str;
   34455           0 :                         PyObject *unicode = NULL;
   34456           0 :                         if (PyUnicode_Check(value)) {
   34457           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   34458           0 :                                 if (unicode == NULL) {
   34459           0 :                                         return -1;
   34460             :                                 }
   34461           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   34462           0 :                         } else if (PyBytes_Check(value)) {
   34463           0 :                                 test_str = PyBytes_AS_STRING(value);
   34464             :                         } else {
   34465           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   34466           0 :                                 return -1;
   34467             :                         }
   34468           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   34469           0 :                         if (unicode != NULL) {
   34470           0 :                                 Py_DECREF(unicode);
   34471             :                         }
   34472           0 :                         if (talloc_str == NULL) {
   34473           0 :                                 PyErr_NoMemory();
   34474           0 :                                 return -1;
   34475             :                         }
   34476           0 :                         object->in.pwszServerName = talloc_str;
   34477             :                 }
   34478             :         }
   34479           0 :         return 0;
   34480             : }
   34481             : 
   34482           0 : static PyObject *py_DnssrvEnumRecords2_in_get_pszZone(PyObject *obj, void *closure)
   34483             : {
   34484           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(obj);
   34485           0 :         PyObject *py_pszZone;
   34486           0 :         if (object->in.pszZone == NULL) {
   34487           0 :                 Py_RETURN_NONE;
   34488             :         }
   34489           0 :         if (object->in.pszZone == NULL) {
   34490           0 :                 py_pszZone = Py_None;
   34491           0 :                 Py_INCREF(py_pszZone);
   34492             :         } else {
   34493           0 :                 if (object->in.pszZone == NULL) {
   34494           0 :                         py_pszZone = Py_None;
   34495           0 :                         Py_INCREF(py_pszZone);
   34496             :                 } else {
   34497           0 :                         py_pszZone = PyUnicode_Decode(object->in.pszZone, strlen(object->in.pszZone), "utf-8", "ignore");
   34498             :                 }
   34499             :         }
   34500           0 :         return py_pszZone;
   34501             : }
   34502             : 
   34503           0 : static int py_DnssrvEnumRecords2_in_set_pszZone(PyObject *py_obj, PyObject *value, void *closure)
   34504             : {
   34505           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(py_obj);
   34506           0 :         if (value == NULL) {
   34507           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszZone");
   34508           0 :                 return -1;
   34509             :         }
   34510           0 :         if (value == Py_None) {
   34511           0 :                 object->in.pszZone = NULL;
   34512             :         } else {
   34513           0 :                 object->in.pszZone = NULL;
   34514             :                 {
   34515           0 :                         const char *test_str;
   34516           0 :                         const char *talloc_str;
   34517           0 :                         PyObject *unicode = NULL;
   34518           0 :                         if (PyUnicode_Check(value)) {
   34519           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   34520           0 :                                 if (unicode == NULL) {
   34521           0 :                                         return -1;
   34522             :                                 }
   34523           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   34524           0 :                         } else if (PyBytes_Check(value)) {
   34525           0 :                                 test_str = PyBytes_AS_STRING(value);
   34526             :                         } else {
   34527           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   34528           0 :                                 return -1;
   34529             :                         }
   34530           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   34531           0 :                         if (unicode != NULL) {
   34532           0 :                                 Py_DECREF(unicode);
   34533             :                         }
   34534           0 :                         if (talloc_str == NULL) {
   34535           0 :                                 PyErr_NoMemory();
   34536           0 :                                 return -1;
   34537             :                         }
   34538           0 :                         object->in.pszZone = talloc_str;
   34539             :                 }
   34540             :         }
   34541           0 :         return 0;
   34542             : }
   34543             : 
   34544           0 : static PyObject *py_DnssrvEnumRecords2_in_get_pszNodeName(PyObject *obj, void *closure)
   34545             : {
   34546           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(obj);
   34547           0 :         PyObject *py_pszNodeName;
   34548           0 :         if (object->in.pszNodeName == NULL) {
   34549           0 :                 Py_RETURN_NONE;
   34550             :         }
   34551           0 :         if (object->in.pszNodeName == NULL) {
   34552           0 :                 py_pszNodeName = Py_None;
   34553           0 :                 Py_INCREF(py_pszNodeName);
   34554             :         } else {
   34555           0 :                 if (object->in.pszNodeName == NULL) {
   34556           0 :                         py_pszNodeName = Py_None;
   34557           0 :                         Py_INCREF(py_pszNodeName);
   34558             :                 } else {
   34559           0 :                         py_pszNodeName = PyUnicode_Decode(object->in.pszNodeName, strlen(object->in.pszNodeName), "utf-8", "ignore");
   34560             :                 }
   34561             :         }
   34562           0 :         return py_pszNodeName;
   34563             : }
   34564             : 
   34565           0 : static int py_DnssrvEnumRecords2_in_set_pszNodeName(PyObject *py_obj, PyObject *value, void *closure)
   34566             : {
   34567           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(py_obj);
   34568           0 :         if (value == NULL) {
   34569           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszNodeName");
   34570           0 :                 return -1;
   34571             :         }
   34572           0 :         if (value == Py_None) {
   34573           0 :                 object->in.pszNodeName = NULL;
   34574             :         } else {
   34575           0 :                 object->in.pszNodeName = NULL;
   34576             :                 {
   34577           0 :                         const char *test_str;
   34578           0 :                         const char *talloc_str;
   34579           0 :                         PyObject *unicode = NULL;
   34580           0 :                         if (PyUnicode_Check(value)) {
   34581           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   34582           0 :                                 if (unicode == NULL) {
   34583           0 :                                         return -1;
   34584             :                                 }
   34585           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   34586           0 :                         } else if (PyBytes_Check(value)) {
   34587           0 :                                 test_str = PyBytes_AS_STRING(value);
   34588             :                         } else {
   34589           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   34590           0 :                                 return -1;
   34591             :                         }
   34592           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   34593           0 :                         if (unicode != NULL) {
   34594           0 :                                 Py_DECREF(unicode);
   34595             :                         }
   34596           0 :                         if (talloc_str == NULL) {
   34597           0 :                                 PyErr_NoMemory();
   34598           0 :                                 return -1;
   34599             :                         }
   34600           0 :                         object->in.pszNodeName = talloc_str;
   34601             :                 }
   34602             :         }
   34603           0 :         return 0;
   34604             : }
   34605             : 
   34606           0 : static PyObject *py_DnssrvEnumRecords2_in_get_pszStartChild(PyObject *obj, void *closure)
   34607             : {
   34608           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(obj);
   34609           0 :         PyObject *py_pszStartChild;
   34610           0 :         if (object->in.pszStartChild == NULL) {
   34611           0 :                 Py_RETURN_NONE;
   34612             :         }
   34613           0 :         if (object->in.pszStartChild == NULL) {
   34614           0 :                 py_pszStartChild = Py_None;
   34615           0 :                 Py_INCREF(py_pszStartChild);
   34616             :         } else {
   34617           0 :                 if (object->in.pszStartChild == NULL) {
   34618           0 :                         py_pszStartChild = Py_None;
   34619           0 :                         Py_INCREF(py_pszStartChild);
   34620             :                 } else {
   34621           0 :                         py_pszStartChild = PyUnicode_Decode(object->in.pszStartChild, strlen(object->in.pszStartChild), "utf-8", "ignore");
   34622             :                 }
   34623             :         }
   34624           0 :         return py_pszStartChild;
   34625             : }
   34626             : 
   34627           0 : static int py_DnssrvEnumRecords2_in_set_pszStartChild(PyObject *py_obj, PyObject *value, void *closure)
   34628             : {
   34629           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(py_obj);
   34630           0 :         if (value == NULL) {
   34631           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszStartChild");
   34632           0 :                 return -1;
   34633             :         }
   34634           0 :         if (value == Py_None) {
   34635           0 :                 object->in.pszStartChild = NULL;
   34636             :         } else {
   34637           0 :                 object->in.pszStartChild = NULL;
   34638             :                 {
   34639           0 :                         const char *test_str;
   34640           0 :                         const char *talloc_str;
   34641           0 :                         PyObject *unicode = NULL;
   34642           0 :                         if (PyUnicode_Check(value)) {
   34643           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   34644           0 :                                 if (unicode == NULL) {
   34645           0 :                                         return -1;
   34646             :                                 }
   34647           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   34648           0 :                         } else if (PyBytes_Check(value)) {
   34649           0 :                                 test_str = PyBytes_AS_STRING(value);
   34650             :                         } else {
   34651           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   34652           0 :                                 return -1;
   34653             :                         }
   34654           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   34655           0 :                         if (unicode != NULL) {
   34656           0 :                                 Py_DECREF(unicode);
   34657             :                         }
   34658           0 :                         if (talloc_str == NULL) {
   34659           0 :                                 PyErr_NoMemory();
   34660           0 :                                 return -1;
   34661             :                         }
   34662           0 :                         object->in.pszStartChild = talloc_str;
   34663             :                 }
   34664             :         }
   34665           0 :         return 0;
   34666             : }
   34667             : 
   34668           0 : static PyObject *py_DnssrvEnumRecords2_in_get_wRecordType(PyObject *obj, void *closure)
   34669             : {
   34670           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(obj);
   34671           0 :         PyObject *py_wRecordType;
   34672           0 :         py_wRecordType = PyLong_FromLong((uint16_t)(object->in.wRecordType));
   34673           0 :         return py_wRecordType;
   34674             : }
   34675             : 
   34676           0 : static int py_DnssrvEnumRecords2_in_set_wRecordType(PyObject *py_obj, PyObject *value, void *closure)
   34677             : {
   34678           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(py_obj);
   34679           0 :         if (value == NULL) {
   34680           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.wRecordType");
   34681           0 :                 return -1;
   34682             :         }
   34683             :         {
   34684           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.wRecordType));
   34685           0 :                 if (PyLong_Check(value)) {
   34686           0 :                         unsigned long long test_var;
   34687           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   34688           0 :                         if (PyErr_Occurred() != NULL) {
   34689           0 :                                 return -1;
   34690             :                         }
   34691           0 :                         if (test_var > uint_max) {
   34692           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   34693             :                                   PyLong_Type.tp_name, uint_max, test_var);
   34694           0 :                                 return -1;
   34695             :                         }
   34696           0 :                         object->in.wRecordType = test_var;
   34697             :                 } else {
   34698           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   34699             :                           PyLong_Type.tp_name);
   34700           0 :                         return -1;
   34701             :                 }
   34702             :         }
   34703           0 :         return 0;
   34704             : }
   34705             : 
   34706           0 : static PyObject *py_DnssrvEnumRecords2_in_get_fSelectFlag(PyObject *obj, void *closure)
   34707             : {
   34708           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(obj);
   34709           0 :         PyObject *py_fSelectFlag;
   34710           0 :         py_fSelectFlag = PyLong_FromUnsignedLongLong((uint32_t)(object->in.fSelectFlag));
   34711           0 :         return py_fSelectFlag;
   34712             : }
   34713             : 
   34714           0 : static int py_DnssrvEnumRecords2_in_set_fSelectFlag(PyObject *py_obj, PyObject *value, void *closure)
   34715             : {
   34716           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(py_obj);
   34717           0 :         if (value == NULL) {
   34718           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.fSelectFlag");
   34719           0 :                 return -1;
   34720             :         }
   34721             :         {
   34722           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.fSelectFlag));
   34723           0 :                 if (PyLong_Check(value)) {
   34724           0 :                         unsigned long long test_var;
   34725           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   34726           0 :                         if (PyErr_Occurred() != NULL) {
   34727           0 :                                 return -1;
   34728             :                         }
   34729           0 :                         if (test_var > uint_max) {
   34730           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   34731             :                                   PyLong_Type.tp_name, uint_max, test_var);
   34732           0 :                                 return -1;
   34733             :                         }
   34734           0 :                         object->in.fSelectFlag = test_var;
   34735             :                 } else {
   34736           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   34737             :                           PyLong_Type.tp_name);
   34738           0 :                         return -1;
   34739             :                 }
   34740             :         }
   34741           0 :         return 0;
   34742             : }
   34743             : 
   34744           0 : static PyObject *py_DnssrvEnumRecords2_in_get_pszFilterStart(PyObject *obj, void *closure)
   34745             : {
   34746           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(obj);
   34747           0 :         PyObject *py_pszFilterStart;
   34748           0 :         if (object->in.pszFilterStart == NULL) {
   34749           0 :                 Py_RETURN_NONE;
   34750             :         }
   34751           0 :         if (object->in.pszFilterStart == NULL) {
   34752           0 :                 py_pszFilterStart = Py_None;
   34753           0 :                 Py_INCREF(py_pszFilterStart);
   34754             :         } else {
   34755           0 :                 if (object->in.pszFilterStart == NULL) {
   34756           0 :                         py_pszFilterStart = Py_None;
   34757           0 :                         Py_INCREF(py_pszFilterStart);
   34758             :                 } else {
   34759           0 :                         py_pszFilterStart = PyUnicode_Decode(object->in.pszFilterStart, strlen(object->in.pszFilterStart), "utf-8", "ignore");
   34760             :                 }
   34761             :         }
   34762           0 :         return py_pszFilterStart;
   34763             : }
   34764             : 
   34765           0 : static int py_DnssrvEnumRecords2_in_set_pszFilterStart(PyObject *py_obj, PyObject *value, void *closure)
   34766             : {
   34767           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(py_obj);
   34768           0 :         if (value == NULL) {
   34769           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszFilterStart");
   34770           0 :                 return -1;
   34771             :         }
   34772           0 :         if (value == Py_None) {
   34773           0 :                 object->in.pszFilterStart = NULL;
   34774             :         } else {
   34775           0 :                 object->in.pszFilterStart = NULL;
   34776             :                 {
   34777           0 :                         const char *test_str;
   34778           0 :                         const char *talloc_str;
   34779           0 :                         PyObject *unicode = NULL;
   34780           0 :                         if (PyUnicode_Check(value)) {
   34781           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   34782           0 :                                 if (unicode == NULL) {
   34783           0 :                                         return -1;
   34784             :                                 }
   34785           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   34786           0 :                         } else if (PyBytes_Check(value)) {
   34787           0 :                                 test_str = PyBytes_AS_STRING(value);
   34788             :                         } else {
   34789           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   34790           0 :                                 return -1;
   34791             :                         }
   34792           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   34793           0 :                         if (unicode != NULL) {
   34794           0 :                                 Py_DECREF(unicode);
   34795             :                         }
   34796           0 :                         if (talloc_str == NULL) {
   34797           0 :                                 PyErr_NoMemory();
   34798           0 :                                 return -1;
   34799             :                         }
   34800           0 :                         object->in.pszFilterStart = talloc_str;
   34801             :                 }
   34802             :         }
   34803           0 :         return 0;
   34804             : }
   34805             : 
   34806           0 : static PyObject *py_DnssrvEnumRecords2_in_get_pszFilterStop(PyObject *obj, void *closure)
   34807             : {
   34808           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(obj);
   34809           0 :         PyObject *py_pszFilterStop;
   34810           0 :         if (object->in.pszFilterStop == NULL) {
   34811           0 :                 Py_RETURN_NONE;
   34812             :         }
   34813           0 :         if (object->in.pszFilterStop == NULL) {
   34814           0 :                 py_pszFilterStop = Py_None;
   34815           0 :                 Py_INCREF(py_pszFilterStop);
   34816             :         } else {
   34817           0 :                 if (object->in.pszFilterStop == NULL) {
   34818           0 :                         py_pszFilterStop = Py_None;
   34819           0 :                         Py_INCREF(py_pszFilterStop);
   34820             :                 } else {
   34821           0 :                         py_pszFilterStop = PyUnicode_Decode(object->in.pszFilterStop, strlen(object->in.pszFilterStop), "utf-8", "ignore");
   34822             :                 }
   34823             :         }
   34824           0 :         return py_pszFilterStop;
   34825             : }
   34826             : 
   34827           0 : static int py_DnssrvEnumRecords2_in_set_pszFilterStop(PyObject *py_obj, PyObject *value, void *closure)
   34828             : {
   34829           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(py_obj);
   34830           0 :         if (value == NULL) {
   34831           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszFilterStop");
   34832           0 :                 return -1;
   34833             :         }
   34834           0 :         if (value == Py_None) {
   34835           0 :                 object->in.pszFilterStop = NULL;
   34836             :         } else {
   34837           0 :                 object->in.pszFilterStop = NULL;
   34838             :                 {
   34839           0 :                         const char *test_str;
   34840           0 :                         const char *talloc_str;
   34841           0 :                         PyObject *unicode = NULL;
   34842           0 :                         if (PyUnicode_Check(value)) {
   34843           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   34844           0 :                                 if (unicode == NULL) {
   34845           0 :                                         return -1;
   34846             :                                 }
   34847           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   34848           0 :                         } else if (PyBytes_Check(value)) {
   34849           0 :                                 test_str = PyBytes_AS_STRING(value);
   34850             :                         } else {
   34851           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   34852           0 :                                 return -1;
   34853             :                         }
   34854           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   34855           0 :                         if (unicode != NULL) {
   34856           0 :                                 Py_DECREF(unicode);
   34857             :                         }
   34858           0 :                         if (talloc_str == NULL) {
   34859           0 :                                 PyErr_NoMemory();
   34860           0 :                                 return -1;
   34861             :                         }
   34862           0 :                         object->in.pszFilterStop = talloc_str;
   34863             :                 }
   34864             :         }
   34865           0 :         return 0;
   34866             : }
   34867             : 
   34868           0 : static PyObject *py_DnssrvEnumRecords2_out_get_pdwBufferLength(PyObject *obj, void *closure)
   34869             : {
   34870           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(obj);
   34871           0 :         PyObject *py_pdwBufferLength;
   34872           0 :         if (object->out.pdwBufferLength == NULL) {
   34873           0 :                 Py_RETURN_NONE;
   34874             :         }
   34875           0 :         py_pdwBufferLength = PyLong_FromUnsignedLongLong((uint32_t)(*object->out.pdwBufferLength));
   34876           0 :         return py_pdwBufferLength;
   34877             : }
   34878             : 
   34879           0 : static int py_DnssrvEnumRecords2_out_set_pdwBufferLength(PyObject *py_obj, PyObject *value, void *closure)
   34880             : {
   34881           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(py_obj);
   34882           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.pdwBufferLength));
   34883           0 :         if (value == NULL) {
   34884           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.pdwBufferLength");
   34885           0 :                 return -1;
   34886             :         }
   34887           0 :         object->out.pdwBufferLength = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.pdwBufferLength);
   34888           0 :         if (object->out.pdwBufferLength == NULL) {
   34889           0 :                 PyErr_NoMemory();
   34890           0 :                 return -1;
   34891             :         }
   34892             :         {
   34893           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(*object->out.pdwBufferLength));
   34894           0 :                 if (PyLong_Check(value)) {
   34895           0 :                         unsigned long long test_var;
   34896           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   34897           0 :                         if (PyErr_Occurred() != NULL) {
   34898           0 :                                 return -1;
   34899             :                         }
   34900           0 :                         if (test_var > uint_max) {
   34901           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   34902             :                                   PyLong_Type.tp_name, uint_max, test_var);
   34903           0 :                                 return -1;
   34904             :                         }
   34905           0 :                         *object->out.pdwBufferLength = test_var;
   34906             :                 } else {
   34907           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   34908             :                           PyLong_Type.tp_name);
   34909           0 :                         return -1;
   34910             :                 }
   34911             :         }
   34912           0 :         return 0;
   34913             : }
   34914             : 
   34915           0 : static PyObject *py_DnssrvEnumRecords2_out_get_pBuffer(PyObject *obj, void *closure)
   34916             : {
   34917           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(obj);
   34918           0 :         PyObject *py_pBuffer;
   34919           0 :         if (object->out.pBuffer == NULL) {
   34920           0 :                 Py_RETURN_NONE;
   34921             :         }
   34922           0 :         if (*object->out.pBuffer == NULL) {
   34923           0 :                 py_pBuffer = Py_None;
   34924           0 :                 Py_INCREF(py_pBuffer);
   34925             :         } else {
   34926           0 :                 py_pBuffer = pytalloc_reference_ex(&DNS_RPC_RECORDS_ARRAY_Type, *object->out.pBuffer, *object->out.pBuffer);
   34927             :         }
   34928           0 :         return py_pBuffer;
   34929             : }
   34930             : 
   34931           0 : static int py_DnssrvEnumRecords2_out_set_pBuffer(PyObject *py_obj, PyObject *value, void *closure)
   34932             : {
   34933           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(py_obj);
   34934           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.pBuffer));
   34935           0 :         if (value == NULL) {
   34936           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.pBuffer");
   34937           0 :                 return -1;
   34938             :         }
   34939           0 :         object->out.pBuffer = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.pBuffer);
   34940           0 :         if (object->out.pBuffer == NULL) {
   34941           0 :                 PyErr_NoMemory();
   34942           0 :                 return -1;
   34943             :         }
   34944           0 :         if (value == Py_None) {
   34945           0 :                 *object->out.pBuffer = NULL;
   34946             :         } else {
   34947           0 :                 *object->out.pBuffer = NULL;
   34948           0 :                 PY_CHECK_TYPE(&DNS_RPC_RECORDS_ARRAY_Type, value, return -1;);
   34949           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   34950           0 :                         PyErr_NoMemory();
   34951           0 :                         return -1;
   34952             :                 }
   34953           0 :                 *object->out.pBuffer = (struct DNS_RPC_RECORDS_ARRAY *)pytalloc_get_ptr(value);
   34954             :         }
   34955           0 :         return 0;
   34956             : }
   34957             : 
   34958           0 : static PyObject *py_DnssrvEnumRecords2_get_result(PyObject *obj, void *closure)
   34959             : {
   34960           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(obj);
   34961           0 :         PyObject *py_result;
   34962           0 :         py_result = PyErr_FromWERROR(object->out.result);
   34963           0 :         return py_result;
   34964             : }
   34965             : 
   34966           0 : static int py_DnssrvEnumRecords2_set_result(PyObject *py_obj, PyObject *value, void *closure)
   34967             : {
   34968           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(py_obj);
   34969           0 :         if (value == NULL) {
   34970           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.result");
   34971           0 :                 return -1;
   34972             :         }
   34973           0 :         object->out.result = W_ERROR(PyLong_AsLong(value));
   34974           0 :         return 0;
   34975             : }
   34976             : 
   34977             : static PyGetSetDef py_DnssrvEnumRecords2_getsetters[] = {
   34978             :         {
   34979             :                 .name = discard_const_p(char, "in_dwClientVersion"),
   34980             :                 .get = py_DnssrvEnumRecords2_in_get_dwClientVersion,
   34981             :                 .set = py_DnssrvEnumRecords2_in_set_dwClientVersion,
   34982             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_CLIENT_VERSION")
   34983             :         },
   34984             :         {
   34985             :                 .name = discard_const_p(char, "in_dwSettingFlags"),
   34986             :                 .get = py_DnssrvEnumRecords2_in_get_dwSettingFlags,
   34987             :                 .set = py_DnssrvEnumRecords2_in_set_dwSettingFlags,
   34988             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   34989             :         },
   34990             :         {
   34991             :                 .name = discard_const_p(char, "in_pwszServerName"),
   34992             :                 .get = py_DnssrvEnumRecords2_in_get_pwszServerName,
   34993             :                 .set = py_DnssrvEnumRecords2_in_set_pwszServerName,
   34994             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
   34995             :         },
   34996             :         {
   34997             :                 .name = discard_const_p(char, "in_pszZone"),
   34998             :                 .get = py_DnssrvEnumRecords2_in_get_pszZone,
   34999             :                 .set = py_DnssrvEnumRecords2_in_set_pszZone,
   35000             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   35001             :         },
   35002             :         {
   35003             :                 .name = discard_const_p(char, "in_pszNodeName"),
   35004             :                 .get = py_DnssrvEnumRecords2_in_get_pszNodeName,
   35005             :                 .set = py_DnssrvEnumRecords2_in_set_pszNodeName,
   35006             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   35007             :         },
   35008             :         {
   35009             :                 .name = discard_const_p(char, "in_pszStartChild"),
   35010             :                 .get = py_DnssrvEnumRecords2_in_get_pszStartChild,
   35011             :                 .set = py_DnssrvEnumRecords2_in_set_pszStartChild,
   35012             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   35013             :         },
   35014             :         {
   35015             :                 .name = discard_const_p(char, "in_wRecordType"),
   35016             :                 .get = py_DnssrvEnumRecords2_in_get_wRecordType,
   35017             :                 .set = py_DnssrvEnumRecords2_in_set_wRecordType,
   35018             :                 .doc = discard_const_p(char, "PIDL-generated element of base type dns_record_type")
   35019             :         },
   35020             :         {
   35021             :                 .name = discard_const_p(char, "in_fSelectFlag"),
   35022             :                 .get = py_DnssrvEnumRecords2_in_get_fSelectFlag,
   35023             :                 .set = py_DnssrvEnumRecords2_in_set_fSelectFlag,
   35024             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_SELECT_FLAGS")
   35025             :         },
   35026             :         {
   35027             :                 .name = discard_const_p(char, "in_pszFilterStart"),
   35028             :                 .get = py_DnssrvEnumRecords2_in_get_pszFilterStart,
   35029             :                 .set = py_DnssrvEnumRecords2_in_set_pszFilterStart,
   35030             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   35031             :         },
   35032             :         {
   35033             :                 .name = discard_const_p(char, "in_pszFilterStop"),
   35034             :                 .get = py_DnssrvEnumRecords2_in_get_pszFilterStop,
   35035             :                 .set = py_DnssrvEnumRecords2_in_set_pszFilterStop,
   35036             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   35037             :         },
   35038             :         {
   35039             :                 .name = discard_const_p(char, "out_pdwBufferLength"),
   35040             :                 .get = py_DnssrvEnumRecords2_out_get_pdwBufferLength,
   35041             :                 .set = py_DnssrvEnumRecords2_out_set_pdwBufferLength,
   35042             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   35043             :         },
   35044             :         {
   35045             :                 .name = discard_const_p(char, "out_pBuffer"),
   35046             :                 .get = py_DnssrvEnumRecords2_out_get_pBuffer,
   35047             :                 .set = py_DnssrvEnumRecords2_out_set_pBuffer,
   35048             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_RECORDS_ARRAY")
   35049             :         },
   35050             :         {
   35051             :                 .name = discard_const_p(char, "result"),
   35052             :                 .get = py_DnssrvEnumRecords2_get_result,
   35053             :                 .set = py_DnssrvEnumRecords2_set_result,
   35054             :                 .doc = discard_const_p(char, "PIDL-generated element of type WERROR")
   35055             :         },
   35056             :         { .name = NULL }
   35057             : };
   35058             : 
   35059           0 : static PyObject *py_DnssrvEnumRecords2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   35060             : {
   35061           0 :         PyObject *self = pytalloc_new(struct DnssrvEnumRecords2, type);
   35062           0 :         struct DnssrvEnumRecords2 *_self = (struct DnssrvEnumRecords2 *)pytalloc_get_ptr(self);
   35063           0 :         TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self);
   35064           0 :         _self->out.pdwBufferLength = talloc_zero(mem_ctx, uint32_t);
   35065             :         /* a pointer to a NULL pointer */
   35066           0 :         _self->out.pBuffer = talloc_zero(mem_ctx, struct DNS_RPC_RECORDS_ARRAY *);
   35067           0 :         return self;
   35068             : }
   35069             : 
   35070           0 : static PyObject *py_DnssrvEnumRecords2_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
   35071             : {
   35072             : 
   35073             : 
   35074           0 :         return PyLong_FromLong(8);
   35075             : }
   35076             : 
   35077           0 : static PyObject *py_DnssrvEnumRecords2_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
   35078             : {
   35079           0 :         const struct ndr_interface_call *call = NULL;
   35080           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(py_obj);
   35081           0 :         PyObject *ret = NULL;
   35082           0 :         struct ndr_push *push = NULL;
   35083           0 :         DATA_BLOB blob;
   35084           0 :         enum ndr_err_code err;
   35085             : 
   35086           0 :         if (ndr_table_dnsserver.num_calls < 9) {
   35087           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvEnumRecords2_ndr_pack");
   35088           0 :                 return NULL;
   35089             :         }
   35090           0 :         call = &ndr_table_dnsserver.calls[8];
   35091             : 
   35092           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
   35093           0 :         if (push == NULL) {
   35094           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
   35095           0 :                 return NULL;
   35096             :         }
   35097             : 
   35098           0 :         push->flags |= ndr_push_flags;
   35099             : 
   35100           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
   35101           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   35102           0 :                 TALLOC_FREE(push);
   35103           0 :                 PyErr_SetNdrError(err);
   35104           0 :                 return NULL;
   35105             :         }
   35106           0 :         blob = ndr_push_blob(push);
   35107           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
   35108           0 :         TALLOC_FREE(push);
   35109           0 :         return ret;
   35110             : }
   35111             : 
   35112           0 : static PyObject *py_DnssrvEnumRecords2_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   35113             : {
   35114           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
   35115           0 :         PyObject *bigendian_obj = NULL;
   35116           0 :         PyObject *ndr64_obj = NULL;
   35117           0 :         libndr_flags ndr_push_flags = 0;
   35118             : 
   35119           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
   35120             :                 discard_const_p(char *, kwnames),
   35121             :                 &bigendian_obj,
   35122             :                 &ndr64_obj)) {
   35123           0 :                 return NULL;
   35124             :         }
   35125             : 
   35126           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   35127           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
   35128             :         }
   35129           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   35130           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
   35131             :         }
   35132             : 
   35133           0 :         return py_DnssrvEnumRecords2_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
   35134             : }
   35135             : 
   35136           0 : static PyObject *py_DnssrvEnumRecords2_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   35137             : {
   35138           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
   35139           0 :         PyObject *bigendian_obj = NULL;
   35140           0 :         PyObject *ndr64_obj = NULL;
   35141           0 :         libndr_flags ndr_push_flags = 0;
   35142             : 
   35143           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
   35144             :                 discard_const_p(char *, kwnames),
   35145             :                 &bigendian_obj,
   35146             :                 &ndr64_obj)) {
   35147           0 :                 return NULL;
   35148             :         }
   35149             : 
   35150           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   35151           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
   35152             :         }
   35153           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   35154           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
   35155             :         }
   35156             : 
   35157           0 :         return py_DnssrvEnumRecords2_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
   35158             : }
   35159             : 
   35160           0 : static PyObject *py_DnssrvEnumRecords2_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
   35161             : {
   35162           0 :         const struct ndr_interface_call *call = NULL;
   35163           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(py_obj);
   35164           0 :         struct ndr_pull *pull = NULL;
   35165           0 :         enum ndr_err_code err;
   35166             : 
   35167           0 :         if (ndr_table_dnsserver.num_calls < 9) {
   35168           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvEnumRecords2_ndr_unpack");
   35169           0 :                 return NULL;
   35170             :         }
   35171           0 :         call = &ndr_table_dnsserver.calls[8];
   35172             : 
   35173           0 :         pull = ndr_pull_init_blob(blob, object);
   35174           0 :         if (pull == NULL) {
   35175           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
   35176           0 :                 return NULL;
   35177             :         }
   35178             : 
   35179           0 :         pull->flags |= ndr_pull_flags;
   35180             : 
   35181           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
   35182           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   35183           0 :                 TALLOC_FREE(pull);
   35184           0 :                 PyErr_SetNdrError(err);
   35185           0 :                 return NULL;
   35186             :         }
   35187           0 :         if (!allow_remaining) {
   35188           0 :                 uint32_t highest_ofs;
   35189             : 
   35190           0 :                 if (pull->offset > pull->relative_highest_offset) {
   35191           0 :                         highest_ofs = pull->offset;
   35192             :                 } else {
   35193           0 :                         highest_ofs = pull->relative_highest_offset;
   35194             :                 }
   35195           0 :                 if (highest_ofs < pull->data_size) {
   35196           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
   35197             :                                 "not all bytes consumed ofs[%u] size[%u]",
   35198             :                                 highest_ofs, pull->data_size);
   35199           0 :                         TALLOC_FREE(pull);
   35200           0 :                         PyErr_SetNdrError(err);
   35201           0 :                         return NULL;
   35202             :                 }
   35203             :         }
   35204             : 
   35205           0 :         TALLOC_FREE(pull);
   35206           0 :         Py_RETURN_NONE;
   35207             : }
   35208             : 
   35209           0 : static PyObject *py_DnssrvEnumRecords2_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   35210             : {
   35211           0 :         DATA_BLOB blob;
   35212           0 :         Py_ssize_t blob_length = 0;
   35213           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
   35214           0 :         PyObject *bigendian_obj = NULL;
   35215           0 :         PyObject *ndr64_obj = NULL;
   35216           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
   35217           0 :         PyObject *allow_remaining_obj = NULL;
   35218           0 :         bool allow_remaining = false;
   35219             : 
   35220           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
   35221             :                 discard_const_p(char *, kwnames),
   35222             :                 &blob.data, &blob_length,
   35223             :                 &bigendian_obj,
   35224             :                 &ndr64_obj,
   35225             :                 &allow_remaining_obj)) {
   35226           0 :                 return NULL;
   35227             :         }
   35228           0 :         blob.length = blob_length;
   35229             : 
   35230           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   35231           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
   35232             :         }
   35233           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   35234           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
   35235             :         }
   35236             : 
   35237           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
   35238           0 :                 allow_remaining = true;
   35239             :         }
   35240             : 
   35241           0 :         return py_DnssrvEnumRecords2_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
   35242             : }
   35243             : 
   35244           0 : static PyObject *py_DnssrvEnumRecords2_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   35245             : {
   35246           0 :         DATA_BLOB blob;
   35247           0 :         Py_ssize_t blob_length = 0;
   35248           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
   35249           0 :         PyObject *bigendian_obj = NULL;
   35250           0 :         PyObject *ndr64_obj = NULL;
   35251           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
   35252           0 :         PyObject *allow_remaining_obj = NULL;
   35253           0 :         bool allow_remaining = false;
   35254             : 
   35255           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
   35256             :                 discard_const_p(char *, kwnames),
   35257             :                 &blob.data, &blob_length,
   35258             :                 &bigendian_obj,
   35259             :                 &ndr64_obj,
   35260             :                 &allow_remaining_obj)) {
   35261           0 :                 return NULL;
   35262             :         }
   35263           0 :         blob.length = blob_length;
   35264             : 
   35265           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   35266           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
   35267             :         }
   35268           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   35269           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
   35270             :         }
   35271             : 
   35272           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
   35273           0 :                 allow_remaining = true;
   35274             :         }
   35275             : 
   35276           0 :         return py_DnssrvEnumRecords2_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
   35277             : }
   35278             : 
   35279           0 : static PyObject *py_DnssrvEnumRecords2_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
   35280             : {
   35281           0 :         const struct ndr_interface_call *call = NULL;
   35282           0 :         struct DnssrvEnumRecords2 *object = pytalloc_get_ptr(py_obj);
   35283           0 :         PyObject *ret;
   35284           0 :         char *retstr;
   35285             : 
   35286           0 :         if (ndr_table_dnsserver.num_calls < 9) {
   35287           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvEnumRecords2_ndr_print");
   35288           0 :                 return NULL;
   35289             :         }
   35290           0 :         call = &ndr_table_dnsserver.calls[8];
   35291             : 
   35292           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
   35293           0 :         ret = PyUnicode_FromString(retstr);
   35294           0 :         TALLOC_FREE(retstr);
   35295             : 
   35296           0 :         return ret;
   35297             : }
   35298             : 
   35299           0 : static PyObject *py_DnssrvEnumRecords2_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
   35300             : {
   35301           0 :         return py_DnssrvEnumRecords2_ndr_print(py_obj, "DnssrvEnumRecords2_in", NDR_IN);
   35302             : }
   35303             : 
   35304           0 : static PyObject *py_DnssrvEnumRecords2_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
   35305             : {
   35306           0 :         return py_DnssrvEnumRecords2_ndr_print(py_obj, "DnssrvEnumRecords2_out", NDR_OUT);
   35307             : }
   35308             : 
   35309             : static PyMethodDef py_DnssrvEnumRecords2_methods[] = {
   35310             :         { "opnum", (PyCFunction)py_DnssrvEnumRecords2_ndr_opnum, METH_NOARGS|METH_CLASS,
   35311             :                 "dnsserver.DnssrvEnumRecords2.opnum() -> 8 (0x08) " },
   35312             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvEnumRecords2_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
   35313             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
   35314             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvEnumRecords2_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
   35315             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
   35316             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvEnumRecords2_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
   35317             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
   35318             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvEnumRecords2_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
   35319             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
   35320             :         { "__ndr_print_in__", (PyCFunction)py_DnssrvEnumRecords2_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
   35321             :         { "__ndr_print_out__", (PyCFunction)py_DnssrvEnumRecords2_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
   35322             :         { NULL, NULL, 0, NULL }
   35323             : };
   35324             : 
   35325             : 
   35326             : static PyTypeObject DnssrvEnumRecords2_Type = {
   35327             :         PyVarObject_HEAD_INIT(NULL, 0)
   35328             :         .tp_name = "dnsserver.DnssrvEnumRecords2",
   35329             :         .tp_getset = py_DnssrvEnumRecords2_getsetters,
   35330             :         .tp_methods = py_DnssrvEnumRecords2_methods,
   35331             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   35332             :         .tp_new = py_DnssrvEnumRecords2_new,
   35333             : };
   35334             : 
   35335        1262 : static bool pack_py_DnssrvEnumRecords2_args_in(PyObject *args, PyObject *kwargs, struct DnssrvEnumRecords2 *r)
   35336             : {
   35337           0 :         PyObject *py_dwClientVersion;
   35338           0 :         PyObject *py_dwSettingFlags;
   35339           0 :         PyObject *py_pwszServerName;
   35340           0 :         PyObject *py_pszZone;
   35341           0 :         PyObject *py_pszNodeName;
   35342           0 :         PyObject *py_pszStartChild;
   35343           0 :         PyObject *py_wRecordType;
   35344           0 :         PyObject *py_fSelectFlag;
   35345           0 :         PyObject *py_pszFilterStart;
   35346           0 :         PyObject *py_pszFilterStop;
   35347        1262 :         const char *kwnames[] = {
   35348             :                 "dwClientVersion", "dwSettingFlags", "pwszServerName", "pszZone", "pszNodeName", "pszStartChild", "wRecordType", "fSelectFlag", "pszFilterStart", "pszFilterStop", NULL
   35349             :         };
   35350             : 
   35351        1262 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOOO:DnssrvEnumRecords2", discard_const_p(char *, kwnames), &py_dwClientVersion, &py_dwSettingFlags, &py_pwszServerName, &py_pszZone, &py_pszNodeName, &py_pszStartChild, &py_wRecordType, &py_fSelectFlag, &py_pszFilterStart, &py_pszFilterStop)) {
   35352           0 :                 return false;
   35353             :         }
   35354             : 
   35355        1262 :         if (py_dwClientVersion == NULL) {
   35356           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.dwClientVersion");
   35357           0 :                 return false;
   35358             :         }
   35359             :         {
   35360        1262 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.dwClientVersion));
   35361        1262 :                 if (PyLong_Check(py_dwClientVersion)) {
   35362           0 :                         unsigned long long test_var;
   35363        1262 :                         test_var = PyLong_AsUnsignedLongLong(py_dwClientVersion);
   35364        1262 :                         if (PyErr_Occurred() != NULL) {
   35365           0 :                                 return false;
   35366             :                         }
   35367        1262 :                         if (test_var > uint_max) {
   35368           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   35369             :                                   PyLong_Type.tp_name, uint_max, test_var);
   35370           0 :                                 return false;
   35371             :                         }
   35372        1262 :                         r->in.dwClientVersion = test_var;
   35373             :                 } else {
   35374           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   35375             :                           PyLong_Type.tp_name);
   35376           0 :                         return false;
   35377             :                 }
   35378             :         }
   35379        1262 :         if (py_dwSettingFlags == NULL) {
   35380           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.dwSettingFlags");
   35381           0 :                 return false;
   35382             :         }
   35383             :         {
   35384        1262 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.dwSettingFlags));
   35385        1262 :                 if (PyLong_Check(py_dwSettingFlags)) {
   35386           0 :                         unsigned long long test_var;
   35387        1262 :                         test_var = PyLong_AsUnsignedLongLong(py_dwSettingFlags);
   35388        1262 :                         if (PyErr_Occurred() != NULL) {
   35389           0 :                                 return false;
   35390             :                         }
   35391        1262 :                         if (test_var > uint_max) {
   35392           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   35393             :                                   PyLong_Type.tp_name, uint_max, test_var);
   35394           0 :                                 return false;
   35395             :                         }
   35396        1262 :                         r->in.dwSettingFlags = test_var;
   35397             :                 } else {
   35398           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   35399             :                           PyLong_Type.tp_name);
   35400           0 :                         return false;
   35401             :                 }
   35402             :         }
   35403        1262 :         if (py_pwszServerName == NULL) {
   35404           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pwszServerName");
   35405           0 :                 return false;
   35406             :         }
   35407        1262 :         if (py_pwszServerName == Py_None) {
   35408           0 :                 r->in.pwszServerName = NULL;
   35409             :         } else {
   35410        1262 :                 r->in.pwszServerName = NULL;
   35411             :                 {
   35412           0 :                         const char *test_str;
   35413           0 :                         const char *talloc_str;
   35414        1262 :                         PyObject *unicode = NULL;
   35415        1262 :                         if (PyUnicode_Check(py_pwszServerName)) {
   35416        1262 :                                 unicode = PyUnicode_AsEncodedString(py_pwszServerName, "utf-8", "ignore");
   35417        1262 :                                 if (unicode == NULL) {
   35418           0 :                                         return false;
   35419             :                                 }
   35420        1262 :                                 test_str = PyBytes_AS_STRING(unicode);
   35421           0 :                         } else if (PyBytes_Check(py_pwszServerName)) {
   35422           0 :                                 test_str = PyBytes_AS_STRING(py_pwszServerName);
   35423             :                         } else {
   35424           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pwszServerName)->tp_name);
   35425           0 :                                 return false;
   35426             :                         }
   35427        1262 :                         talloc_str = talloc_strdup(r, test_str);
   35428        1262 :                         if (unicode != NULL) {
   35429         932 :                                 Py_DECREF(unicode);
   35430             :                         }
   35431        1262 :                         if (talloc_str == NULL) {
   35432           0 :                                 PyErr_NoMemory();
   35433           0 :                                 return false;
   35434             :                         }
   35435        1262 :                         r->in.pwszServerName = talloc_str;
   35436             :                 }
   35437             :         }
   35438        1262 :         if (py_pszZone == NULL) {
   35439           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszZone");
   35440           0 :                 return false;
   35441             :         }
   35442        1262 :         if (py_pszZone == Py_None) {
   35443           0 :                 r->in.pszZone = NULL;
   35444             :         } else {
   35445        1262 :                 r->in.pszZone = NULL;
   35446             :                 {
   35447           0 :                         const char *test_str;
   35448           0 :                         const char *talloc_str;
   35449        1262 :                         PyObject *unicode = NULL;
   35450        1262 :                         if (PyUnicode_Check(py_pszZone)) {
   35451        1262 :                                 unicode = PyUnicode_AsEncodedString(py_pszZone, "utf-8", "ignore");
   35452        1262 :                                 if (unicode == NULL) {
   35453           0 :                                         return false;
   35454             :                                 }
   35455        1262 :                                 test_str = PyBytes_AS_STRING(unicode);
   35456           0 :                         } else if (PyBytes_Check(py_pszZone)) {
   35457           0 :                                 test_str = PyBytes_AS_STRING(py_pszZone);
   35458             :                         } else {
   35459           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszZone)->tp_name);
   35460           0 :                                 return false;
   35461             :                         }
   35462        1262 :                         talloc_str = talloc_strdup(r, test_str);
   35463        1262 :                         if (unicode != NULL) {
   35464         932 :                                 Py_DECREF(unicode);
   35465             :                         }
   35466        1262 :                         if (talloc_str == NULL) {
   35467           0 :                                 PyErr_NoMemory();
   35468           0 :                                 return false;
   35469             :                         }
   35470        1262 :                         r->in.pszZone = talloc_str;
   35471             :                 }
   35472             :         }
   35473        1262 :         if (py_pszNodeName == NULL) {
   35474           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszNodeName");
   35475           0 :                 return false;
   35476             :         }
   35477        1262 :         if (py_pszNodeName == Py_None) {
   35478           0 :                 r->in.pszNodeName = NULL;
   35479             :         } else {
   35480        1262 :                 r->in.pszNodeName = NULL;
   35481             :                 {
   35482           0 :                         const char *test_str;
   35483           0 :                         const char *talloc_str;
   35484        1262 :                         PyObject *unicode = NULL;
   35485        1262 :                         if (PyUnicode_Check(py_pszNodeName)) {
   35486        1262 :                                 unicode = PyUnicode_AsEncodedString(py_pszNodeName, "utf-8", "ignore");
   35487        1262 :                                 if (unicode == NULL) {
   35488           0 :                                         return false;
   35489             :                                 }
   35490        1262 :                                 test_str = PyBytes_AS_STRING(unicode);
   35491           0 :                         } else if (PyBytes_Check(py_pszNodeName)) {
   35492           0 :                                 test_str = PyBytes_AS_STRING(py_pszNodeName);
   35493             :                         } else {
   35494           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszNodeName)->tp_name);
   35495           0 :                                 return false;
   35496             :                         }
   35497        1262 :                         talloc_str = talloc_strdup(r, test_str);
   35498        1262 :                         if (unicode != NULL) {
   35499         932 :                                 Py_DECREF(unicode);
   35500             :                         }
   35501        1262 :                         if (talloc_str == NULL) {
   35502           0 :                                 PyErr_NoMemory();
   35503           0 :                                 return false;
   35504             :                         }
   35505        1262 :                         r->in.pszNodeName = talloc_str;
   35506             :                 }
   35507             :         }
   35508        1262 :         if (py_pszStartChild == NULL) {
   35509           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszStartChild");
   35510           0 :                 return false;
   35511             :         }
   35512        1262 :         if (py_pszStartChild == Py_None) {
   35513        1262 :                 r->in.pszStartChild = NULL;
   35514             :         } else {
   35515           0 :                 r->in.pszStartChild = NULL;
   35516             :                 {
   35517           0 :                         const char *test_str;
   35518           0 :                         const char *talloc_str;
   35519           0 :                         PyObject *unicode = NULL;
   35520           0 :                         if (PyUnicode_Check(py_pszStartChild)) {
   35521           0 :                                 unicode = PyUnicode_AsEncodedString(py_pszStartChild, "utf-8", "ignore");
   35522           0 :                                 if (unicode == NULL) {
   35523           0 :                                         return false;
   35524             :                                 }
   35525           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   35526           0 :                         } else if (PyBytes_Check(py_pszStartChild)) {
   35527           0 :                                 test_str = PyBytes_AS_STRING(py_pszStartChild);
   35528             :                         } else {
   35529           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszStartChild)->tp_name);
   35530           0 :                                 return false;
   35531             :                         }
   35532           0 :                         talloc_str = talloc_strdup(r, test_str);
   35533           0 :                         if (unicode != NULL) {
   35534           0 :                                 Py_DECREF(unicode);
   35535             :                         }
   35536           0 :                         if (talloc_str == NULL) {
   35537           0 :                                 PyErr_NoMemory();
   35538           0 :                                 return false;
   35539             :                         }
   35540           0 :                         r->in.pszStartChild = talloc_str;
   35541             :                 }
   35542             :         }
   35543        1262 :         if (py_wRecordType == NULL) {
   35544           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.wRecordType");
   35545           0 :                 return false;
   35546             :         }
   35547             :         {
   35548        1262 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.wRecordType));
   35549        1262 :                 if (PyLong_Check(py_wRecordType)) {
   35550           0 :                         unsigned long long test_var;
   35551        1262 :                         test_var = PyLong_AsUnsignedLongLong(py_wRecordType);
   35552        1262 :                         if (PyErr_Occurred() != NULL) {
   35553           0 :                                 return false;
   35554             :                         }
   35555        1262 :                         if (test_var > uint_max) {
   35556           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   35557             :                                   PyLong_Type.tp_name, uint_max, test_var);
   35558           0 :                                 return false;
   35559             :                         }
   35560        1262 :                         r->in.wRecordType = test_var;
   35561             :                 } else {
   35562           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   35563             :                           PyLong_Type.tp_name);
   35564           0 :                         return false;
   35565             :                 }
   35566             :         }
   35567        1262 :         if (py_fSelectFlag == NULL) {
   35568           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.fSelectFlag");
   35569           0 :                 return false;
   35570             :         }
   35571             :         {
   35572        1262 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.fSelectFlag));
   35573        1262 :                 if (PyLong_Check(py_fSelectFlag)) {
   35574           0 :                         unsigned long long test_var;
   35575        1262 :                         test_var = PyLong_AsUnsignedLongLong(py_fSelectFlag);
   35576        1262 :                         if (PyErr_Occurred() != NULL) {
   35577           0 :                                 return false;
   35578             :                         }
   35579        1262 :                         if (test_var > uint_max) {
   35580           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   35581             :                                   PyLong_Type.tp_name, uint_max, test_var);
   35582           0 :                                 return false;
   35583             :                         }
   35584        1262 :                         r->in.fSelectFlag = test_var;
   35585             :                 } else {
   35586           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   35587             :                           PyLong_Type.tp_name);
   35588           0 :                         return false;
   35589             :                 }
   35590             :         }
   35591        1262 :         if (py_pszFilterStart == NULL) {
   35592           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszFilterStart");
   35593           0 :                 return false;
   35594             :         }
   35595        1262 :         if (py_pszFilterStart == Py_None) {
   35596        1262 :                 r->in.pszFilterStart = NULL;
   35597             :         } else {
   35598           0 :                 r->in.pszFilterStart = NULL;
   35599             :                 {
   35600           0 :                         const char *test_str;
   35601           0 :                         const char *talloc_str;
   35602           0 :                         PyObject *unicode = NULL;
   35603           0 :                         if (PyUnicode_Check(py_pszFilterStart)) {
   35604           0 :                                 unicode = PyUnicode_AsEncodedString(py_pszFilterStart, "utf-8", "ignore");
   35605           0 :                                 if (unicode == NULL) {
   35606           0 :                                         return false;
   35607             :                                 }
   35608           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   35609           0 :                         } else if (PyBytes_Check(py_pszFilterStart)) {
   35610           0 :                                 test_str = PyBytes_AS_STRING(py_pszFilterStart);
   35611             :                         } else {
   35612           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszFilterStart)->tp_name);
   35613           0 :                                 return false;
   35614             :                         }
   35615           0 :                         talloc_str = talloc_strdup(r, test_str);
   35616           0 :                         if (unicode != NULL) {
   35617           0 :                                 Py_DECREF(unicode);
   35618             :                         }
   35619           0 :                         if (talloc_str == NULL) {
   35620           0 :                                 PyErr_NoMemory();
   35621           0 :                                 return false;
   35622             :                         }
   35623           0 :                         r->in.pszFilterStart = talloc_str;
   35624             :                 }
   35625             :         }
   35626        1262 :         if (py_pszFilterStop == NULL) {
   35627           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszFilterStop");
   35628           0 :                 return false;
   35629             :         }
   35630        1262 :         if (py_pszFilterStop == Py_None) {
   35631        1262 :                 r->in.pszFilterStop = NULL;
   35632             :         } else {
   35633           0 :                 r->in.pszFilterStop = NULL;
   35634             :                 {
   35635           0 :                         const char *test_str;
   35636           0 :                         const char *talloc_str;
   35637           0 :                         PyObject *unicode = NULL;
   35638           0 :                         if (PyUnicode_Check(py_pszFilterStop)) {
   35639           0 :                                 unicode = PyUnicode_AsEncodedString(py_pszFilterStop, "utf-8", "ignore");
   35640           0 :                                 if (unicode == NULL) {
   35641           0 :                                         return false;
   35642             :                                 }
   35643           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   35644           0 :                         } else if (PyBytes_Check(py_pszFilterStop)) {
   35645           0 :                                 test_str = PyBytes_AS_STRING(py_pszFilterStop);
   35646             :                         } else {
   35647           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszFilterStop)->tp_name);
   35648           0 :                                 return false;
   35649             :                         }
   35650           0 :                         talloc_str = talloc_strdup(r, test_str);
   35651           0 :                         if (unicode != NULL) {
   35652           0 :                                 Py_DECREF(unicode);
   35653             :                         }
   35654           0 :                         if (talloc_str == NULL) {
   35655           0 :                                 PyErr_NoMemory();
   35656           0 :                                 return false;
   35657             :                         }
   35658           0 :                         r->in.pszFilterStop = talloc_str;
   35659             :                 }
   35660             :         }
   35661        1262 :         return true;
   35662             : }
   35663             : 
   35664        1262 : static PyObject *unpack_py_DnssrvEnumRecords2_args_out(struct DnssrvEnumRecords2 *r)
   35665             : {
   35666           0 :         PyObject *result;
   35667           0 :         PyObject *py_pdwBufferLength;
   35668           0 :         PyObject *py_pBuffer;
   35669        1262 :         result = PyTuple_New(2);
   35670        1262 :         py_pdwBufferLength = PyLong_FromUnsignedLongLong((uint32_t)(*r->out.pdwBufferLength));
   35671        1262 :         PyTuple_SetItem(result, 0, py_pdwBufferLength);
   35672        1262 :         if (*r->out.pBuffer == NULL) {
   35673         182 :                 py_pBuffer = Py_None;
   35674         141 :                 Py_INCREF(py_pBuffer);
   35675             :         } else {
   35676        1080 :                 py_pBuffer = pytalloc_reference_ex(&DNS_RPC_RECORDS_ARRAY_Type, *r->out.pBuffer, *r->out.pBuffer);
   35677             :         }
   35678        1262 :         PyTuple_SetItem(result, 1, py_pBuffer);
   35679        1262 :         if (!W_ERROR_IS_OK(r->out.result)) {
   35680         182 :                 PyErr_SetWERROR(r->out.result);
   35681         182 :                 return NULL;
   35682             :         }
   35683             : 
   35684        1080 :         return result;
   35685             : }
   35686             : 
   35687             : 
   35688           0 : static PyObject *py_DnssrvUpdateRecord2_in_get_dwClientVersion(PyObject *obj, void *closure)
   35689             : {
   35690           0 :         struct DnssrvUpdateRecord2 *object = pytalloc_get_ptr(obj);
   35691           0 :         PyObject *py_dwClientVersion;
   35692           0 :         py_dwClientVersion = PyLong_FromUnsignedLongLong((uint32_t)(object->in.dwClientVersion));
   35693           0 :         return py_dwClientVersion;
   35694             : }
   35695             : 
   35696           0 : static int py_DnssrvUpdateRecord2_in_set_dwClientVersion(PyObject *py_obj, PyObject *value, void *closure)
   35697             : {
   35698           0 :         struct DnssrvUpdateRecord2 *object = pytalloc_get_ptr(py_obj);
   35699           0 :         if (value == NULL) {
   35700           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.dwClientVersion");
   35701           0 :                 return -1;
   35702             :         }
   35703             :         {
   35704           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.dwClientVersion));
   35705           0 :                 if (PyLong_Check(value)) {
   35706           0 :                         unsigned long long test_var;
   35707           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   35708           0 :                         if (PyErr_Occurred() != NULL) {
   35709           0 :                                 return -1;
   35710             :                         }
   35711           0 :                         if (test_var > uint_max) {
   35712           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   35713             :                                   PyLong_Type.tp_name, uint_max, test_var);
   35714           0 :                                 return -1;
   35715             :                         }
   35716           0 :                         object->in.dwClientVersion = test_var;
   35717             :                 } else {
   35718           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   35719             :                           PyLong_Type.tp_name);
   35720           0 :                         return -1;
   35721             :                 }
   35722             :         }
   35723           0 :         return 0;
   35724             : }
   35725             : 
   35726           0 : static PyObject *py_DnssrvUpdateRecord2_in_get_dwSettingFlags(PyObject *obj, void *closure)
   35727             : {
   35728           0 :         struct DnssrvUpdateRecord2 *object = pytalloc_get_ptr(obj);
   35729           0 :         PyObject *py_dwSettingFlags;
   35730           0 :         py_dwSettingFlags = PyLong_FromUnsignedLongLong((uint32_t)(object->in.dwSettingFlags));
   35731           0 :         return py_dwSettingFlags;
   35732             : }
   35733             : 
   35734           0 : static int py_DnssrvUpdateRecord2_in_set_dwSettingFlags(PyObject *py_obj, PyObject *value, void *closure)
   35735             : {
   35736           0 :         struct DnssrvUpdateRecord2 *object = pytalloc_get_ptr(py_obj);
   35737           0 :         if (value == NULL) {
   35738           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.dwSettingFlags");
   35739           0 :                 return -1;
   35740             :         }
   35741             :         {
   35742           0 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->in.dwSettingFlags));
   35743           0 :                 if (PyLong_Check(value)) {
   35744           0 :                         unsigned long long test_var;
   35745           0 :                         test_var = PyLong_AsUnsignedLongLong(value);
   35746           0 :                         if (PyErr_Occurred() != NULL) {
   35747           0 :                                 return -1;
   35748             :                         }
   35749           0 :                         if (test_var > uint_max) {
   35750           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   35751             :                                   PyLong_Type.tp_name, uint_max, test_var);
   35752           0 :                                 return -1;
   35753             :                         }
   35754           0 :                         object->in.dwSettingFlags = test_var;
   35755             :                 } else {
   35756           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   35757             :                           PyLong_Type.tp_name);
   35758           0 :                         return -1;
   35759             :                 }
   35760             :         }
   35761           0 :         return 0;
   35762             : }
   35763             : 
   35764           0 : static PyObject *py_DnssrvUpdateRecord2_in_get_pwszServerName(PyObject *obj, void *closure)
   35765             : {
   35766           0 :         struct DnssrvUpdateRecord2 *object = pytalloc_get_ptr(obj);
   35767           0 :         PyObject *py_pwszServerName;
   35768           0 :         if (object->in.pwszServerName == NULL) {
   35769           0 :                 Py_RETURN_NONE;
   35770             :         }
   35771           0 :         if (object->in.pwszServerName == NULL) {
   35772           0 :                 py_pwszServerName = Py_None;
   35773           0 :                 Py_INCREF(py_pwszServerName);
   35774             :         } else {
   35775           0 :                 if (object->in.pwszServerName == NULL) {
   35776           0 :                         py_pwszServerName = Py_None;
   35777           0 :                         Py_INCREF(py_pwszServerName);
   35778             :                 } else {
   35779           0 :                         py_pwszServerName = PyUnicode_Decode(object->in.pwszServerName, strlen(object->in.pwszServerName), "utf-8", "ignore");
   35780             :                 }
   35781             :         }
   35782           0 :         return py_pwszServerName;
   35783             : }
   35784             : 
   35785           0 : static int py_DnssrvUpdateRecord2_in_set_pwszServerName(PyObject *py_obj, PyObject *value, void *closure)
   35786             : {
   35787           0 :         struct DnssrvUpdateRecord2 *object = pytalloc_get_ptr(py_obj);
   35788           0 :         if (value == NULL) {
   35789           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pwszServerName");
   35790           0 :                 return -1;
   35791             :         }
   35792           0 :         if (value == Py_None) {
   35793           0 :                 object->in.pwszServerName = NULL;
   35794             :         } else {
   35795           0 :                 object->in.pwszServerName = NULL;
   35796             :                 {
   35797           0 :                         const char *test_str;
   35798           0 :                         const char *talloc_str;
   35799           0 :                         PyObject *unicode = NULL;
   35800           0 :                         if (PyUnicode_Check(value)) {
   35801           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   35802           0 :                                 if (unicode == NULL) {
   35803           0 :                                         return -1;
   35804             :                                 }
   35805           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   35806           0 :                         } else if (PyBytes_Check(value)) {
   35807           0 :                                 test_str = PyBytes_AS_STRING(value);
   35808             :                         } else {
   35809           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   35810           0 :                                 return -1;
   35811             :                         }
   35812           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   35813           0 :                         if (unicode != NULL) {
   35814           0 :                                 Py_DECREF(unicode);
   35815             :                         }
   35816           0 :                         if (talloc_str == NULL) {
   35817           0 :                                 PyErr_NoMemory();
   35818           0 :                                 return -1;
   35819             :                         }
   35820           0 :                         object->in.pwszServerName = talloc_str;
   35821             :                 }
   35822             :         }
   35823           0 :         return 0;
   35824             : }
   35825             : 
   35826           0 : static PyObject *py_DnssrvUpdateRecord2_in_get_pszZone(PyObject *obj, void *closure)
   35827             : {
   35828           0 :         struct DnssrvUpdateRecord2 *object = pytalloc_get_ptr(obj);
   35829           0 :         PyObject *py_pszZone;
   35830           0 :         if (object->in.pszZone == NULL) {
   35831           0 :                 Py_RETURN_NONE;
   35832             :         }
   35833           0 :         if (object->in.pszZone == NULL) {
   35834           0 :                 py_pszZone = Py_None;
   35835           0 :                 Py_INCREF(py_pszZone);
   35836             :         } else {
   35837           0 :                 if (object->in.pszZone == NULL) {
   35838           0 :                         py_pszZone = Py_None;
   35839           0 :                         Py_INCREF(py_pszZone);
   35840             :                 } else {
   35841           0 :                         py_pszZone = PyUnicode_Decode(object->in.pszZone, strlen(object->in.pszZone), "utf-8", "ignore");
   35842             :                 }
   35843             :         }
   35844           0 :         return py_pszZone;
   35845             : }
   35846             : 
   35847           0 : static int py_DnssrvUpdateRecord2_in_set_pszZone(PyObject *py_obj, PyObject *value, void *closure)
   35848             : {
   35849           0 :         struct DnssrvUpdateRecord2 *object = pytalloc_get_ptr(py_obj);
   35850           0 :         if (value == NULL) {
   35851           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszZone");
   35852           0 :                 return -1;
   35853             :         }
   35854           0 :         if (value == Py_None) {
   35855           0 :                 object->in.pszZone = NULL;
   35856             :         } else {
   35857           0 :                 object->in.pszZone = NULL;
   35858             :                 {
   35859           0 :                         const char *test_str;
   35860           0 :                         const char *talloc_str;
   35861           0 :                         PyObject *unicode = NULL;
   35862           0 :                         if (PyUnicode_Check(value)) {
   35863           0 :                                 unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   35864           0 :                                 if (unicode == NULL) {
   35865           0 :                                         return -1;
   35866             :                                 }
   35867           0 :                                 test_str = PyBytes_AS_STRING(unicode);
   35868           0 :                         } else if (PyBytes_Check(value)) {
   35869           0 :                                 test_str = PyBytes_AS_STRING(value);
   35870             :                         } else {
   35871           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   35872           0 :                                 return -1;
   35873             :                         }
   35874           0 :                         talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   35875           0 :                         if (unicode != NULL) {
   35876           0 :                                 Py_DECREF(unicode);
   35877             :                         }
   35878           0 :                         if (talloc_str == NULL) {
   35879           0 :                                 PyErr_NoMemory();
   35880           0 :                                 return -1;
   35881             :                         }
   35882           0 :                         object->in.pszZone = talloc_str;
   35883             :                 }
   35884             :         }
   35885           0 :         return 0;
   35886             : }
   35887             : 
   35888           0 : static PyObject *py_DnssrvUpdateRecord2_in_get_pszNodeName(PyObject *obj, void *closure)
   35889             : {
   35890           0 :         struct DnssrvUpdateRecord2 *object = pytalloc_get_ptr(obj);
   35891           0 :         PyObject *py_pszNodeName;
   35892           0 :         if (object->in.pszNodeName == NULL) {
   35893           0 :                 Py_RETURN_NONE;
   35894             :         }
   35895           0 :         if (object->in.pszNodeName == NULL) {
   35896           0 :                 py_pszNodeName = Py_None;
   35897           0 :                 Py_INCREF(py_pszNodeName);
   35898             :         } else {
   35899           0 :                 py_pszNodeName = PyUnicode_Decode(object->in.pszNodeName, strlen(object->in.pszNodeName), "utf-8", "ignore");
   35900             :         }
   35901           0 :         return py_pszNodeName;
   35902             : }
   35903             : 
   35904           0 : static int py_DnssrvUpdateRecord2_in_set_pszNodeName(PyObject *py_obj, PyObject *value, void *closure)
   35905             : {
   35906           0 :         struct DnssrvUpdateRecord2 *object = pytalloc_get_ptr(py_obj);
   35907           0 :         if (value == NULL) {
   35908           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pszNodeName");
   35909           0 :                 return -1;
   35910             :         }
   35911           0 :         object->in.pszNodeName = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->in.pszNodeName);
   35912           0 :         if (object->in.pszNodeName == NULL) {
   35913           0 :                 PyErr_NoMemory();
   35914           0 :                 return -1;
   35915             :         }
   35916             :         {
   35917           0 :                 const char *test_str;
   35918           0 :                 const char *talloc_str;
   35919           0 :                 PyObject *unicode = NULL;
   35920           0 :                 if (PyUnicode_Check(value)) {
   35921           0 :                         unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore");
   35922           0 :                         if (unicode == NULL) {
   35923           0 :                                 return -1;
   35924             :                         }
   35925           0 :                         test_str = PyBytes_AS_STRING(unicode);
   35926           0 :                 } else if (PyBytes_Check(value)) {
   35927           0 :                         test_str = PyBytes_AS_STRING(value);
   35928             :                 } else {
   35929           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
   35930           0 :                         return -1;
   35931             :                 }
   35932           0 :                 talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str);
   35933           0 :                 if (unicode != NULL) {
   35934           0 :                         Py_DECREF(unicode);
   35935             :                 }
   35936           0 :                 if (talloc_str == NULL) {
   35937           0 :                         PyErr_NoMemory();
   35938           0 :                         return -1;
   35939             :                 }
   35940           0 :                 object->in.pszNodeName = talloc_str;
   35941             :         }
   35942           0 :         return 0;
   35943             : }
   35944             : 
   35945           0 : static PyObject *py_DnssrvUpdateRecord2_in_get_pAddRecord(PyObject *obj, void *closure)
   35946             : {
   35947           0 :         struct DnssrvUpdateRecord2 *object = pytalloc_get_ptr(obj);
   35948           0 :         PyObject *py_pAddRecord;
   35949           0 :         if (object->in.pAddRecord == NULL) {
   35950           0 :                 Py_RETURN_NONE;
   35951             :         }
   35952           0 :         if (object->in.pAddRecord == NULL) {
   35953           0 :                 py_pAddRecord = Py_None;
   35954           0 :                 Py_INCREF(py_pAddRecord);
   35955             :         } else {
   35956           0 :                 py_pAddRecord = pytalloc_reference_ex(&DNS_RPC_RECORD_BUF_Type, object->in.pAddRecord, object->in.pAddRecord);
   35957             :         }
   35958           0 :         return py_pAddRecord;
   35959             : }
   35960             : 
   35961           0 : static int py_DnssrvUpdateRecord2_in_set_pAddRecord(PyObject *py_obj, PyObject *value, void *closure)
   35962             : {
   35963           0 :         struct DnssrvUpdateRecord2 *object = pytalloc_get_ptr(py_obj);
   35964           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.pAddRecord));
   35965           0 :         if (value == NULL) {
   35966           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pAddRecord");
   35967           0 :                 return -1;
   35968             :         }
   35969           0 :         if (value == Py_None) {
   35970           0 :                 object->in.pAddRecord = NULL;
   35971             :         } else {
   35972           0 :                 object->in.pAddRecord = NULL;
   35973           0 :                 PY_CHECK_TYPE(&DNS_RPC_RECORD_BUF_Type, value, return -1;);
   35974           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   35975           0 :                         PyErr_NoMemory();
   35976           0 :                         return -1;
   35977             :                 }
   35978           0 :                 object->in.pAddRecord = (struct DNS_RPC_RECORD_BUF *)pytalloc_get_ptr(value);
   35979             :         }
   35980           0 :         return 0;
   35981             : }
   35982             : 
   35983           0 : static PyObject *py_DnssrvUpdateRecord2_in_get_pDeleteRecord(PyObject *obj, void *closure)
   35984             : {
   35985           0 :         struct DnssrvUpdateRecord2 *object = pytalloc_get_ptr(obj);
   35986           0 :         PyObject *py_pDeleteRecord;
   35987           0 :         if (object->in.pDeleteRecord == NULL) {
   35988           0 :                 Py_RETURN_NONE;
   35989             :         }
   35990           0 :         if (object->in.pDeleteRecord == NULL) {
   35991           0 :                 py_pDeleteRecord = Py_None;
   35992           0 :                 Py_INCREF(py_pDeleteRecord);
   35993             :         } else {
   35994           0 :                 py_pDeleteRecord = pytalloc_reference_ex(&DNS_RPC_RECORD_BUF_Type, object->in.pDeleteRecord, object->in.pDeleteRecord);
   35995             :         }
   35996           0 :         return py_pDeleteRecord;
   35997             : }
   35998             : 
   35999           0 : static int py_DnssrvUpdateRecord2_in_set_pDeleteRecord(PyObject *py_obj, PyObject *value, void *closure)
   36000             : {
   36001           0 :         struct DnssrvUpdateRecord2 *object = pytalloc_get_ptr(py_obj);
   36002           0 :         talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->in.pDeleteRecord));
   36003           0 :         if (value == NULL) {
   36004           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->in.pDeleteRecord");
   36005           0 :                 return -1;
   36006             :         }
   36007           0 :         if (value == Py_None) {
   36008           0 :                 object->in.pDeleteRecord = NULL;
   36009             :         } else {
   36010           0 :                 object->in.pDeleteRecord = NULL;
   36011           0 :                 PY_CHECK_TYPE(&DNS_RPC_RECORD_BUF_Type, value, return -1;);
   36012           0 :                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
   36013           0 :                         PyErr_NoMemory();
   36014           0 :                         return -1;
   36015             :                 }
   36016           0 :                 object->in.pDeleteRecord = (struct DNS_RPC_RECORD_BUF *)pytalloc_get_ptr(value);
   36017             :         }
   36018           0 :         return 0;
   36019             : }
   36020             : 
   36021           0 : static PyObject *py_DnssrvUpdateRecord2_get_result(PyObject *obj, void *closure)
   36022             : {
   36023           0 :         struct DnssrvUpdateRecord2 *object = pytalloc_get_ptr(obj);
   36024           0 :         PyObject *py_result;
   36025           0 :         py_result = PyErr_FromWERROR(object->out.result);
   36026           0 :         return py_result;
   36027             : }
   36028             : 
   36029           0 : static int py_DnssrvUpdateRecord2_set_result(PyObject *py_obj, PyObject *value, void *closure)
   36030             : {
   36031           0 :         struct DnssrvUpdateRecord2 *object = pytalloc_get_ptr(py_obj);
   36032           0 :         if (value == NULL) {
   36033           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: object->out.result");
   36034           0 :                 return -1;
   36035             :         }
   36036           0 :         object->out.result = W_ERROR(PyLong_AsLong(value));
   36037           0 :         return 0;
   36038             : }
   36039             : 
   36040             : static PyGetSetDef py_DnssrvUpdateRecord2_getsetters[] = {
   36041             :         {
   36042             :                 .name = discard_const_p(char, "in_dwClientVersion"),
   36043             :                 .get = py_DnssrvUpdateRecord2_in_get_dwClientVersion,
   36044             :                 .set = py_DnssrvUpdateRecord2_in_set_dwClientVersion,
   36045             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_CLIENT_VERSION")
   36046             :         },
   36047             :         {
   36048             :                 .name = discard_const_p(char, "in_dwSettingFlags"),
   36049             :                 .get = py_DnssrvUpdateRecord2_in_get_dwSettingFlags,
   36050             :                 .set = py_DnssrvUpdateRecord2_in_set_dwSettingFlags,
   36051             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint32")
   36052             :         },
   36053             :         {
   36054             :                 .name = discard_const_p(char, "in_pwszServerName"),
   36055             :                 .get = py_DnssrvUpdateRecord2_in_get_pwszServerName,
   36056             :                 .set = py_DnssrvUpdateRecord2_in_set_pwszServerName,
   36057             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint16")
   36058             :         },
   36059             :         {
   36060             :                 .name = discard_const_p(char, "in_pszZone"),
   36061             :                 .get = py_DnssrvUpdateRecord2_in_get_pszZone,
   36062             :                 .set = py_DnssrvUpdateRecord2_in_set_pszZone,
   36063             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   36064             :         },
   36065             :         {
   36066             :                 .name = discard_const_p(char, "in_pszNodeName"),
   36067             :                 .get = py_DnssrvUpdateRecord2_in_get_pszNodeName,
   36068             :                 .set = py_DnssrvUpdateRecord2_in_set_pszNodeName,
   36069             :                 .doc = discard_const_p(char, "PIDL-generated element of base type uint8")
   36070             :         },
   36071             :         {
   36072             :                 .name = discard_const_p(char, "in_pAddRecord"),
   36073             :                 .get = py_DnssrvUpdateRecord2_in_get_pAddRecord,
   36074             :                 .set = py_DnssrvUpdateRecord2_in_set_pAddRecord,
   36075             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_RECORD_BUF")
   36076             :         },
   36077             :         {
   36078             :                 .name = discard_const_p(char, "in_pDeleteRecord"),
   36079             :                 .get = py_DnssrvUpdateRecord2_in_get_pDeleteRecord,
   36080             :                 .set = py_DnssrvUpdateRecord2_in_set_pDeleteRecord,
   36081             :                 .doc = discard_const_p(char, "PIDL-generated element of base type DNS_RPC_RECORD_BUF")
   36082             :         },
   36083             :         {
   36084             :                 .name = discard_const_p(char, "result"),
   36085             :                 .get = py_DnssrvUpdateRecord2_get_result,
   36086             :                 .set = py_DnssrvUpdateRecord2_set_result,
   36087             :                 .doc = discard_const_p(char, "PIDL-generated element of type WERROR")
   36088             :         },
   36089             :         { .name = NULL }
   36090             : };
   36091             : 
   36092           0 : static PyObject *py_DnssrvUpdateRecord2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   36093             : {
   36094           0 :         PyObject *self = pytalloc_new(struct DnssrvUpdateRecord2, type);
   36095           0 :         return self;
   36096             : }
   36097             : 
   36098           0 : static PyObject *py_DnssrvUpdateRecord2_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored))
   36099             : {
   36100             : 
   36101             : 
   36102           0 :         return PyLong_FromLong(9);
   36103             : }
   36104             : 
   36105           0 : static PyObject *py_DnssrvUpdateRecord2_ndr_pack(PyObject *py_obj, ndr_flags_type ndr_inout_flags, libndr_flags ndr_push_flags)
   36106             : {
   36107           0 :         const struct ndr_interface_call *call = NULL;
   36108           0 :         struct DnssrvUpdateRecord2 *object = pytalloc_get_ptr(py_obj);
   36109           0 :         PyObject *ret = NULL;
   36110           0 :         struct ndr_push *push = NULL;
   36111           0 :         DATA_BLOB blob;
   36112           0 :         enum ndr_err_code err;
   36113             : 
   36114           0 :         if (ndr_table_dnsserver.num_calls < 10) {
   36115           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvUpdateRecord2_ndr_pack");
   36116           0 :                 return NULL;
   36117             :         }
   36118           0 :         call = &ndr_table_dnsserver.calls[9];
   36119             : 
   36120           0 :         push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj));
   36121           0 :         if (push == NULL) {
   36122           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
   36123           0 :                 return NULL;
   36124             :         }
   36125             : 
   36126           0 :         push->flags |= ndr_push_flags;
   36127             : 
   36128           0 :         err = call->ndr_push(push, ndr_inout_flags, object);
   36129           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   36130           0 :                 TALLOC_FREE(push);
   36131           0 :                 PyErr_SetNdrError(err);
   36132           0 :                 return NULL;
   36133             :         }
   36134           0 :         blob = ndr_push_blob(push);
   36135           0 :         ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length);
   36136           0 :         TALLOC_FREE(push);
   36137           0 :         return ret;
   36138             : }
   36139             : 
   36140           0 : static PyObject *py_DnssrvUpdateRecord2_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   36141             : {
   36142           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
   36143           0 :         PyObject *bigendian_obj = NULL;
   36144           0 :         PyObject *ndr64_obj = NULL;
   36145           0 :         libndr_flags ndr_push_flags = 0;
   36146             : 
   36147           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__",
   36148             :                 discard_const_p(char *, kwnames),
   36149             :                 &bigendian_obj,
   36150             :                 &ndr64_obj)) {
   36151           0 :                 return NULL;
   36152             :         }
   36153             : 
   36154           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   36155           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
   36156             :         }
   36157           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   36158           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
   36159             :         }
   36160             : 
   36161           0 :         return py_DnssrvUpdateRecord2_ndr_pack(py_obj, NDR_IN, ndr_push_flags);
   36162             : }
   36163             : 
   36164           0 : static PyObject *py_DnssrvUpdateRecord2_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   36165             : {
   36166           0 :         const char * const kwnames[] = { "bigendian", "ndr64", NULL };
   36167           0 :         PyObject *bigendian_obj = NULL;
   36168           0 :         PyObject *ndr64_obj = NULL;
   36169           0 :         libndr_flags ndr_push_flags = 0;
   36170             : 
   36171           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__",
   36172             :                 discard_const_p(char *, kwnames),
   36173             :                 &bigendian_obj,
   36174             :                 &ndr64_obj)) {
   36175           0 :                 return NULL;
   36176             :         }
   36177             : 
   36178           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   36179           0 :                 ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN;
   36180             :         }
   36181           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   36182           0 :                 ndr_push_flags |= LIBNDR_FLAG_NDR64;
   36183             :         }
   36184             : 
   36185           0 :         return py_DnssrvUpdateRecord2_ndr_pack(py_obj, NDR_OUT, ndr_push_flags);
   36186             : }
   36187             : 
   36188           0 : static PyObject *py_DnssrvUpdateRecord2_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, ndr_flags_type ndr_inout_flags, libndr_flags ndr_pull_flags, bool allow_remaining)
   36189             : {
   36190           0 :         const struct ndr_interface_call *call = NULL;
   36191           0 :         struct DnssrvUpdateRecord2 *object = pytalloc_get_ptr(py_obj);
   36192           0 :         struct ndr_pull *pull = NULL;
   36193           0 :         enum ndr_err_code err;
   36194             : 
   36195           0 :         if (ndr_table_dnsserver.num_calls < 10) {
   36196           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvUpdateRecord2_ndr_unpack");
   36197           0 :                 return NULL;
   36198             :         }
   36199           0 :         call = &ndr_table_dnsserver.calls[9];
   36200             : 
   36201           0 :         pull = ndr_pull_init_blob(blob, object);
   36202           0 :         if (pull == NULL) {
   36203           0 :                 PyErr_SetNdrError(NDR_ERR_ALLOC);
   36204           0 :                 return NULL;
   36205             :         }
   36206             : 
   36207           0 :         pull->flags |= ndr_pull_flags;
   36208             : 
   36209           0 :         err = call->ndr_pull(pull, ndr_inout_flags, object);
   36210           0 :         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
   36211           0 :                 TALLOC_FREE(pull);
   36212           0 :                 PyErr_SetNdrError(err);
   36213           0 :                 return NULL;
   36214             :         }
   36215           0 :         if (!allow_remaining) {
   36216           0 :                 uint32_t highest_ofs;
   36217             : 
   36218           0 :                 if (pull->offset > pull->relative_highest_offset) {
   36219           0 :                         highest_ofs = pull->offset;
   36220             :                 } else {
   36221           0 :                         highest_ofs = pull->relative_highest_offset;
   36222             :                 }
   36223           0 :                 if (highest_ofs < pull->data_size) {
   36224           0 :                         err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES,
   36225             :                                 "not all bytes consumed ofs[%u] size[%u]",
   36226             :                                 highest_ofs, pull->data_size);
   36227           0 :                         TALLOC_FREE(pull);
   36228           0 :                         PyErr_SetNdrError(err);
   36229           0 :                         return NULL;
   36230             :                 }
   36231             :         }
   36232             : 
   36233           0 :         TALLOC_FREE(pull);
   36234           0 :         Py_RETURN_NONE;
   36235             : }
   36236             : 
   36237           0 : static PyObject *py_DnssrvUpdateRecord2_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   36238             : {
   36239           0 :         DATA_BLOB blob;
   36240           0 :         Py_ssize_t blob_length = 0;
   36241           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
   36242           0 :         PyObject *bigendian_obj = NULL;
   36243           0 :         PyObject *ndr64_obj = NULL;
   36244           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
   36245           0 :         PyObject *allow_remaining_obj = NULL;
   36246           0 :         bool allow_remaining = false;
   36247             : 
   36248           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__",
   36249             :                 discard_const_p(char *, kwnames),
   36250             :                 &blob.data, &blob_length,
   36251             :                 &bigendian_obj,
   36252             :                 &ndr64_obj,
   36253             :                 &allow_remaining_obj)) {
   36254           0 :                 return NULL;
   36255             :         }
   36256           0 :         blob.length = blob_length;
   36257             : 
   36258           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   36259           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
   36260             :         }
   36261           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   36262           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
   36263             :         }
   36264             : 
   36265           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
   36266           0 :                 allow_remaining = true;
   36267             :         }
   36268             : 
   36269           0 :         return py_DnssrvUpdateRecord2_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining);
   36270             : }
   36271             : 
   36272           0 : static PyObject *py_DnssrvUpdateRecord2_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs)
   36273             : {
   36274           0 :         DATA_BLOB blob;
   36275           0 :         Py_ssize_t blob_length = 0;
   36276           0 :         const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL };
   36277           0 :         PyObject *bigendian_obj = NULL;
   36278           0 :         PyObject *ndr64_obj = NULL;
   36279           0 :         libndr_flags ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC;
   36280           0 :         PyObject *allow_remaining_obj = NULL;
   36281           0 :         bool allow_remaining = false;
   36282             : 
   36283           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__",
   36284             :                 discard_const_p(char *, kwnames),
   36285             :                 &blob.data, &blob_length,
   36286             :                 &bigendian_obj,
   36287             :                 &ndr64_obj,
   36288             :                 &allow_remaining_obj)) {
   36289           0 :                 return NULL;
   36290             :         }
   36291           0 :         blob.length = blob_length;
   36292             : 
   36293           0 :         if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) {
   36294           0 :                 ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN;
   36295             :         }
   36296           0 :         if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) {
   36297           0 :                 ndr_pull_flags |= LIBNDR_FLAG_NDR64;
   36298             :         }
   36299             : 
   36300           0 :         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
   36301           0 :                 allow_remaining = true;
   36302             :         }
   36303             : 
   36304           0 :         return py_DnssrvUpdateRecord2_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining);
   36305             : }
   36306             : 
   36307           0 : static PyObject *py_DnssrvUpdateRecord2_ndr_print(PyObject *py_obj, const char *name, ndr_flags_type ndr_inout_flags)
   36308             : {
   36309           0 :         const struct ndr_interface_call *call = NULL;
   36310           0 :         struct DnssrvUpdateRecord2 *object = pytalloc_get_ptr(py_obj);
   36311           0 :         PyObject *ret;
   36312           0 :         char *retstr;
   36313             : 
   36314           0 :         if (ndr_table_dnsserver.num_calls < 10) {
   36315           0 :                 PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_DnssrvUpdateRecord2_ndr_print");
   36316           0 :                 return NULL;
   36317             :         }
   36318           0 :         call = &ndr_table_dnsserver.calls[9];
   36319             : 
   36320           0 :         retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object);
   36321           0 :         ret = PyUnicode_FromString(retstr);
   36322           0 :         TALLOC_FREE(retstr);
   36323             : 
   36324           0 :         return ret;
   36325             : }
   36326             : 
   36327           0 : static PyObject *py_DnssrvUpdateRecord2_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
   36328             : {
   36329           0 :         return py_DnssrvUpdateRecord2_ndr_print(py_obj, "DnssrvUpdateRecord2_in", NDR_IN);
   36330             : }
   36331             : 
   36332           0 : static PyObject *py_DnssrvUpdateRecord2_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored))
   36333             : {
   36334           0 :         return py_DnssrvUpdateRecord2_ndr_print(py_obj, "DnssrvUpdateRecord2_out", NDR_OUT);
   36335             : }
   36336             : 
   36337             : static PyMethodDef py_DnssrvUpdateRecord2_methods[] = {
   36338             :         { "opnum", (PyCFunction)py_DnssrvUpdateRecord2_ndr_opnum, METH_NOARGS|METH_CLASS,
   36339             :                 "dnsserver.DnssrvUpdateRecord2.opnum() -> 9 (0x09) " },
   36340             :         { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvUpdateRecord2_ndr_pack_in), METH_VARARGS|METH_KEYWORDS,
   36341             :                 "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" },
   36342             :         { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvUpdateRecord2_ndr_pack_out), METH_VARARGS|METH_KEYWORDS,
   36343             :                 "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" },
   36344             :         { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvUpdateRecord2_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS,
   36345             :                 "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" },
   36346             :         { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_DnssrvUpdateRecord2_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS,
   36347             :                 "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" },
   36348             :         { "__ndr_print_in__", (PyCFunction)py_DnssrvUpdateRecord2_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" },
   36349             :         { "__ndr_print_out__", (PyCFunction)py_DnssrvUpdateRecord2_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" },
   36350             :         { NULL, NULL, 0, NULL }
   36351             : };
   36352             : 
   36353             : 
   36354             : static PyTypeObject DnssrvUpdateRecord2_Type = {
   36355             :         PyVarObject_HEAD_INIT(NULL, 0)
   36356             :         .tp_name = "dnsserver.DnssrvUpdateRecord2",
   36357             :         .tp_getset = py_DnssrvUpdateRecord2_getsetters,
   36358             :         .tp_methods = py_DnssrvUpdateRecord2_methods,
   36359             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   36360             :         .tp_new = py_DnssrvUpdateRecord2_new,
   36361             : };
   36362             : 
   36363        4083 : static bool pack_py_DnssrvUpdateRecord2_args_in(PyObject *args, PyObject *kwargs, struct DnssrvUpdateRecord2 *r)
   36364             : {
   36365           0 :         PyObject *py_dwClientVersion;
   36366           0 :         PyObject *py_dwSettingFlags;
   36367           0 :         PyObject *py_pwszServerName;
   36368           0 :         PyObject *py_pszZone;
   36369           0 :         PyObject *py_pszNodeName;
   36370           0 :         PyObject *py_pAddRecord;
   36371           0 :         PyObject *py_pDeleteRecord;
   36372        4083 :         const char *kwnames[] = {
   36373             :                 "dwClientVersion", "dwSettingFlags", "pwszServerName", "pszZone", "pszNodeName", "pAddRecord", "pDeleteRecord", NULL
   36374             :         };
   36375             : 
   36376        4083 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOO:DnssrvUpdateRecord2", discard_const_p(char *, kwnames), &py_dwClientVersion, &py_dwSettingFlags, &py_pwszServerName, &py_pszZone, &py_pszNodeName, &py_pAddRecord, &py_pDeleteRecord)) {
   36377           0 :                 return false;
   36378             :         }
   36379             : 
   36380        4083 :         if (py_dwClientVersion == NULL) {
   36381           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.dwClientVersion");
   36382           0 :                 return false;
   36383             :         }
   36384             :         {
   36385        4083 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.dwClientVersion));
   36386        4083 :                 if (PyLong_Check(py_dwClientVersion)) {
   36387           0 :                         unsigned long long test_var;
   36388        4083 :                         test_var = PyLong_AsUnsignedLongLong(py_dwClientVersion);
   36389        4083 :                         if (PyErr_Occurred() != NULL) {
   36390           0 :                                 return false;
   36391             :                         }
   36392        4083 :                         if (test_var > uint_max) {
   36393           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   36394             :                                   PyLong_Type.tp_name, uint_max, test_var);
   36395           0 :                                 return false;
   36396             :                         }
   36397        4083 :                         r->in.dwClientVersion = test_var;
   36398             :                 } else {
   36399           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   36400             :                           PyLong_Type.tp_name);
   36401           0 :                         return false;
   36402             :                 }
   36403             :         }
   36404        4083 :         if (py_dwSettingFlags == NULL) {
   36405           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.dwSettingFlags");
   36406           0 :                 return false;
   36407             :         }
   36408             :         {
   36409        4083 :                 const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(r->in.dwSettingFlags));
   36410        4083 :                 if (PyLong_Check(py_dwSettingFlags)) {
   36411           0 :                         unsigned long long test_var;
   36412        4083 :                         test_var = PyLong_AsUnsignedLongLong(py_dwSettingFlags);
   36413        4083 :                         if (PyErr_Occurred() != NULL) {
   36414           0 :                                 return false;
   36415             :                         }
   36416        4083 :                         if (test_var > uint_max) {
   36417           0 :                                 PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",
   36418             :                                   PyLong_Type.tp_name, uint_max, test_var);
   36419           0 :                                 return false;
   36420             :                         }
   36421        4083 :                         r->in.dwSettingFlags = test_var;
   36422             :                 } else {
   36423           0 :                         PyErr_Format(PyExc_TypeError, "Expected type %s",
   36424             :                           PyLong_Type.tp_name);
   36425           0 :                         return false;
   36426             :                 }
   36427             :         }
   36428        4083 :         if (py_pwszServerName == NULL) {
   36429           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pwszServerName");
   36430           0 :                 return false;
   36431             :         }
   36432        4083 :         if (py_pwszServerName == Py_None) {
   36433           0 :                 r->in.pwszServerName = NULL;
   36434             :         } else {
   36435        4083 :                 r->in.pwszServerName = NULL;
   36436             :                 {
   36437           0 :                         const char *test_str;
   36438           0 :                         const char *talloc_str;
   36439        4083 :                         PyObject *unicode = NULL;
   36440        4083 :                         if (PyUnicode_Check(py_pwszServerName)) {
   36441        4083 :                                 unicode = PyUnicode_AsEncodedString(py_pwszServerName, "utf-8", "ignore");
   36442        4083 :                                 if (unicode == NULL) {
   36443           0 :                                         return false;
   36444             :                                 }
   36445        4083 :                                 test_str = PyBytes_AS_STRING(unicode);
   36446           0 :                         } else if (PyBytes_Check(py_pwszServerName)) {
   36447           0 :                                 test_str = PyBytes_AS_STRING(py_pwszServerName);
   36448             :                         } else {
   36449           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pwszServerName)->tp_name);
   36450           0 :                                 return false;
   36451             :                         }
   36452        4083 :                         talloc_str = talloc_strdup(r, test_str);
   36453        4083 :                         if (unicode != NULL) {
   36454        3025 :                                 Py_DECREF(unicode);
   36455             :                         }
   36456        4083 :                         if (talloc_str == NULL) {
   36457           0 :                                 PyErr_NoMemory();
   36458           0 :                                 return false;
   36459             :                         }
   36460        4083 :                         r->in.pwszServerName = talloc_str;
   36461             :                 }
   36462             :         }
   36463        4083 :         if (py_pszZone == NULL) {
   36464           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszZone");
   36465           0 :                 return false;
   36466             :         }
   36467        4083 :         if (py_pszZone == Py_None) {
   36468           0 :                 r->in.pszZone = NULL;
   36469             :         } else {
   36470        4083 :                 r->in.pszZone = NULL;
   36471             :                 {
   36472           0 :                         const char *test_str;
   36473           0 :                         const char *talloc_str;
   36474        4083 :                         PyObject *unicode = NULL;
   36475        4083 :                         if (PyUnicode_Check(py_pszZone)) {
   36476        4083 :                                 unicode = PyUnicode_AsEncodedString(py_pszZone, "utf-8", "ignore");
   36477        4083 :                                 if (unicode == NULL) {
   36478           0 :                                         return false;
   36479             :                                 }
   36480        4083 :                                 test_str = PyBytes_AS_STRING(unicode);
   36481           0 :                         } else if (PyBytes_Check(py_pszZone)) {
   36482           0 :                                 test_str = PyBytes_AS_STRING(py_pszZone);
   36483             :                         } else {
   36484           0 :                                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszZone)->tp_name);
   36485           0 :                                 return false;
   36486             :                         }
   36487        4083 :                         talloc_str = talloc_strdup(r, test_str);
   36488        4083 :                         if (unicode != NULL) {
   36489        3025 :                                 Py_DECREF(unicode);
   36490             :                         }
   36491        4083 :                         if (talloc_str == NULL) {
   36492           0 :                                 PyErr_NoMemory();
   36493           0 :                                 return false;
   36494             :                         }
   36495        4083 :                         r->in.pszZone = talloc_str;
   36496             :                 }
   36497             :         }
   36498        4083 :         if (py_pszNodeName == NULL) {
   36499           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pszNodeName");
   36500           0 :                 return false;
   36501             :         }
   36502        4083 :         r->in.pszNodeName = talloc_ptrtype(r, r->in.pszNodeName);
   36503        4083 :         if (r->in.pszNodeName == NULL) {
   36504           0 :                 PyErr_NoMemory();
   36505           0 :                 return false;
   36506             :         }
   36507             :         {
   36508           0 :                 const char *test_str;
   36509           0 :                 const char *talloc_str;
   36510        4083 :                 PyObject *unicode = NULL;
   36511        4083 :                 if (PyUnicode_Check(py_pszNodeName)) {
   36512        4083 :                         unicode = PyUnicode_AsEncodedString(py_pszNodeName, "utf-8", "ignore");
   36513        4083 :                         if (unicode == NULL) {
   36514           0 :                                 return false;
   36515             :                         }
   36516        4083 :                         test_str = PyBytes_AS_STRING(unicode);
   36517           0 :                 } else if (PyBytes_Check(py_pszNodeName)) {
   36518           0 :                         test_str = PyBytes_AS_STRING(py_pszNodeName);
   36519             :                 } else {
   36520           0 :                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_pszNodeName)->tp_name);
   36521           0 :                         return false;
   36522             :                 }
   36523        4083 :                 talloc_str = talloc_strdup(r, test_str);
   36524        4083 :                 if (unicode != NULL) {
   36525        3025 :                         Py_DECREF(unicode);
   36526             :                 }
   36527        4083 :                 if (talloc_str == NULL) {
   36528           0 :                         PyErr_NoMemory();
   36529           0 :                         return false;
   36530             :                 }
   36531        4083 :                 r->in.pszNodeName = talloc_str;
   36532             :         }
   36533        4083 :         if (py_pAddRecord == NULL) {
   36534           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pAddRecord");
   36535           0 :                 return false;
   36536             :         }
   36537        4083 :         if (py_pAddRecord == Py_None) {
   36538        1653 :                 r->in.pAddRecord = NULL;
   36539             :         } else {
   36540        2430 :                 r->in.pAddRecord = NULL;
   36541        2430 :                 PY_CHECK_TYPE(&DNS_RPC_RECORD_BUF_Type, py_pAddRecord, return false;);
   36542        2430 :                 if (talloc_reference(r, pytalloc_get_mem_ctx(py_pAddRecord)) == NULL) {
   36543           0 :                         PyErr_NoMemory();
   36544           0 :                         return false;
   36545             :                 }
   36546        2430 :                 r->in.pAddRecord = (struct DNS_RPC_RECORD_BUF *)pytalloc_get_ptr(py_pAddRecord);
   36547             :         }
   36548        4083 :         if (py_pDeleteRecord == NULL) {
   36549           0 :                 PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: r->in.pDeleteRecord");
   36550           0 :                 return false;
   36551             :         }
   36552        4083 :         if (py_pDeleteRecord == Py_None) {
   36553        2289 :                 r->in.pDeleteRecord = NULL;
   36554             :         } else {
   36555        1794 :                 r->in.pDeleteRecord = NULL;
   36556        1794 :                 PY_CHECK_TYPE(&DNS_RPC_RECORD_BUF_Type, py_pDeleteRecord, return false;);
   36557        1794 :                 if (talloc_reference(r, pytalloc_get_mem_ctx(py_pDeleteRecord)) == NULL) {
   36558           0 :                         PyErr_NoMemory();
   36559           0 :                         return false;
   36560             :                 }
   36561        1794 :                 r->in.pDeleteRecord = (struct DNS_RPC_RECORD_BUF *)pytalloc_get_ptr(py_pDeleteRecord);
   36562             :         }
   36563        4083 :         return true;
   36564             : }
   36565             : 
   36566        3995 : static PyObject *unpack_py_DnssrvUpdateRecord2_args_out(struct DnssrvUpdateRecord2 *r)
   36567             : {
   36568           0 :         PyObject *result;
   36569        3995 :         result = Py_None;
   36570        2961 :         Py_INCREF(result);
   36571        3995 :         if (!W_ERROR_IS_OK(r->out.result)) {
   36572         556 :                 PyErr_SetWERROR(r->out.result);
   36573         556 :                 return NULL;
   36574             :         }
   36575             : 
   36576        3439 :         return result;
   36577             : }
   36578             : 
   36579             : const struct PyNdrRpcMethodDef py_ndr_dnsserver_methods[] = {
   36580             :         { "DnssrvOperation", "S.DnssrvOperation(pwszServerName, pszZone, dwContext, pszOperation, dwTypeId, pData) -> None", (py_dcerpc_call_fn)dcerpc_DnssrvOperation_r, (py_data_pack_fn)pack_py_DnssrvOperation_args_in, (py_data_unpack_fn)unpack_py_DnssrvOperation_args_out, 0, &ndr_table_dnsserver },
   36581             :         { "DnssrvQuery", "S.DnssrvQuery(pwszServerName, pszZone, pszOperation) -> (pdwTypeId, ppData)", (py_dcerpc_call_fn)dcerpc_DnssrvQuery_r, (py_data_pack_fn)pack_py_DnssrvQuery_args_in, (py_data_unpack_fn)unpack_py_DnssrvQuery_args_out, 1, &ndr_table_dnsserver },
   36582             :         { "DnssrvComplexOperation", "S.DnssrvComplexOperation(pwszServerName, pszZone, pszOperation, dwTypeIn, pDataIn) -> (pdwTypeOut, ppDataOut)", (py_dcerpc_call_fn)dcerpc_DnssrvComplexOperation_r, (py_data_pack_fn)pack_py_DnssrvComplexOperation_args_in, (py_data_unpack_fn)unpack_py_DnssrvComplexOperation_args_out, 2, &ndr_table_dnsserver },
   36583             :         { "DnssrvEnumRecords", "S.DnssrvEnumRecords(pwszServerName, pszZone, pszNodeName, pszStartChild, wRecordType, fSelectFlag, pszFilterStart, pszFilterStop) -> (pdwBufferLength, pBuffer)", (py_dcerpc_call_fn)dcerpc_DnssrvEnumRecords_r, (py_data_pack_fn)pack_py_DnssrvEnumRecords_args_in, (py_data_unpack_fn)unpack_py_DnssrvEnumRecords_args_out, 3, &ndr_table_dnsserver },
   36584             :         { "DnssrvUpdateRecord", "S.DnssrvUpdateRecord(pwszServerName, pszZone, pszNodeName, pAddRecord, pDeleteRecord) -> None", (py_dcerpc_call_fn)dcerpc_DnssrvUpdateRecord_r, (py_data_pack_fn)pack_py_DnssrvUpdateRecord_args_in, (py_data_unpack_fn)unpack_py_DnssrvUpdateRecord_args_out, 4, &ndr_table_dnsserver },
   36585             :         { "DnssrvOperation2", "S.DnssrvOperation2(dwClientVersion, dwSettingFlags, pwszServerName, pszZone, dwContext, pszOperation, dwTypeId, pData) -> None", (py_dcerpc_call_fn)dcerpc_DnssrvOperation2_r, (py_data_pack_fn)pack_py_DnssrvOperation2_args_in, (py_data_unpack_fn)unpack_py_DnssrvOperation2_args_out, 5, &ndr_table_dnsserver },
   36586             :         { "DnssrvQuery2", "S.DnssrvQuery2(dwClientVersion, dwSettingFlags, pwszServerName, pszZone, pszOperation) -> (pdwTypeId, ppData)", (py_dcerpc_call_fn)dcerpc_DnssrvQuery2_r, (py_data_pack_fn)pack_py_DnssrvQuery2_args_in, (py_data_unpack_fn)unpack_py_DnssrvQuery2_args_out, 6, &ndr_table_dnsserver },
   36587             :         { "DnssrvComplexOperation2", "S.DnssrvComplexOperation2(dwClientVersion, dwSettingFlags, pwszServerName, pszZone, pszOperation, dwTypeIn, pDataIn) -> (pdwTypeOut, ppDataOut)", (py_dcerpc_call_fn)dcerpc_DnssrvComplexOperation2_r, (py_data_pack_fn)pack_py_DnssrvComplexOperation2_args_in, (py_data_unpack_fn)unpack_py_DnssrvComplexOperation2_args_out, 7, &ndr_table_dnsserver },
   36588             :         { "DnssrvEnumRecords2", "S.DnssrvEnumRecords2(dwClientVersion, dwSettingFlags, pwszServerName, pszZone, pszNodeName, pszStartChild, wRecordType, fSelectFlag, pszFilterStart, pszFilterStop) -> (pdwBufferLength, pBuffer)", (py_dcerpc_call_fn)dcerpc_DnssrvEnumRecords2_r, (py_data_pack_fn)pack_py_DnssrvEnumRecords2_args_in, (py_data_unpack_fn)unpack_py_DnssrvEnumRecords2_args_out, 8, &ndr_table_dnsserver },
   36589             :         { "DnssrvUpdateRecord2", "S.DnssrvUpdateRecord2(dwClientVersion, dwSettingFlags, pwszServerName, pszZone, pszNodeName, pAddRecord, pDeleteRecord) -> None", (py_dcerpc_call_fn)dcerpc_DnssrvUpdateRecord2_r, (py_data_pack_fn)pack_py_DnssrvUpdateRecord2_args_in, (py_data_unpack_fn)unpack_py_DnssrvUpdateRecord2_args_out, 9, &ndr_table_dnsserver },
   36590             :         {0}
   36591             : };
   36592             : 
   36593        1609 : static PyObject *interface_dnsserver_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   36594             : {
   36595        1609 :         return py_dcerpc_interface_init_helper(type, args, kwargs, &ndr_table_dnsserver);
   36596             : }
   36597             : 
   36598             : #define PY_DOC_DNSSERVER "DNS Management Server"
   36599             : static PyTypeObject dnsserver_InterfaceType = {
   36600             :         PyVarObject_HEAD_INIT(NULL, 0)
   36601             :         .tp_name = "dnsserver.dnsserver",
   36602             :         .tp_basicsize = sizeof(dcerpc_InterfaceObject),
   36603             :         .tp_doc = "dnsserver(binding, lp_ctx=None, credentials=None) -> connection\n"
   36604             : "\n"
   36605             : "binding should be a DCE/RPC binding string (for example: ncacn_ip_tcp:127.0.0.1)\n"
   36606             : "lp_ctx should be a path to a smb.conf file or a param.LoadParm object\n"
   36607             : "credentials should be a credentials.Credentials object.\n\n"PY_DOC_DNSSERVER,
   36608             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   36609             :         .tp_new = interface_dnsserver_new,
   36610             : };
   36611             : 
   36612           0 : static PyObject *syntax_dnsserver_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
   36613             : {
   36614           0 :         return py_dcerpc_syntax_init_helper(type, args, kwargs, &ndr_table_dnsserver.syntax_id);
   36615             : }
   36616             : 
   36617             : #define PY_DOC_DNSSERVER_SYNTAX "DNS Management Server"
   36618             : static PyTypeObject dnsserver_SyntaxType = {
   36619             :         PyVarObject_HEAD_INIT(NULL, 0)
   36620             :         .tp_name = "dnsserver.dnsserver_abstract_syntax",
   36621             :         .tp_doc = "dnsserver_abstract_syntax()\n"PY_DOC_DNSSERVER_SYNTAX,
   36622             :         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
   36623             :         .tp_new = syntax_dnsserver_new,
   36624             : };
   36625             : 
   36626             : static PyMethodDef dnsserver_methods[] = {
   36627             :         { NULL, NULL, 0, NULL }
   36628             : };
   36629             : 
   36630             : static struct PyModuleDef moduledef = {
   36631             :         PyModuleDef_HEAD_INIT,
   36632             :         .m_name = "dnsserver",
   36633             :         .m_doc = "dnsserver DCE/RPC",
   36634             :         .m_size = -1,
   36635             :         .m_methods = dnsserver_methods,
   36636             : };
   36637        2907 : MODULE_INIT_FUNC(dnsserver)
   36638             : {
   36639        2907 :         PyObject *m = NULL;
   36640        2907 :         PyObject *dep_samba_dcerpc_misc = NULL;
   36641        2907 :         PyObject *dep_samba_dcerpc_dnsp = NULL;
   36642        2907 :         PyObject *dep_talloc = NULL;
   36643        2907 :         PyObject *dep_samba_dcerpc_base = NULL;
   36644             : 
   36645        2907 :         dep_samba_dcerpc_misc = PyImport_ImportModule("samba.dcerpc.misc");
   36646        2907 :         if (dep_samba_dcerpc_misc == NULL)
   36647           0 :                 goto out;
   36648             : 
   36649        2907 :         dep_samba_dcerpc_dnsp = PyImport_ImportModule("samba.dcerpc.dnsp");
   36650        2907 :         if (dep_samba_dcerpc_dnsp == NULL)
   36651           0 :                 goto out;
   36652             : 
   36653        2907 :         dep_talloc = PyImport_ImportModule("talloc");
   36654        2907 :         if (dep_talloc == NULL)
   36655           0 :                 goto out;
   36656             : 
   36657        2907 :         dep_samba_dcerpc_base = PyImport_ImportModule("samba.dcerpc.base");
   36658        2907 :         if (dep_samba_dcerpc_base == NULL)
   36659           0 :                 goto out;
   36660             : 
   36661        2907 :         BaseObject_Type = (PyTypeObject *)PyObject_GetAttrString(dep_talloc, "BaseObject");
   36662        2907 :         if (BaseObject_Type == NULL)
   36663           0 :                 goto out;
   36664             : 
   36665        2907 :         ClientConnection_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_base, "ClientConnection");
   36666        2907 :         if (ClientConnection_Type == NULL)
   36667           0 :                 goto out;
   36668             : 
   36669        2907 :         ndr_syntax_id_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_misc, "ndr_syntax_id");
   36670        2907 :         if (ndr_syntax_id_Type == NULL)
   36671           0 :                 goto out;
   36672             : 
   36673        2907 :         DNS_RPC_BUFFER_Type.tp_base = BaseObject_Type;
   36674        2907 :         DNS_RPC_BUFFER_Type.tp_basicsize = pytalloc_BaseObject_size();
   36675             : 
   36676        2907 :         DNS_RPC_UTF8_STRING_LIST_Type.tp_base = BaseObject_Type;
   36677        2907 :         DNS_RPC_UTF8_STRING_LIST_Type.tp_basicsize = pytalloc_BaseObject_size();
   36678             : 
   36679        2907 :         DNS_RPC_NAME_AND_PARAM_Type.tp_base = BaseObject_Type;
   36680        2907 :         DNS_RPC_NAME_AND_PARAM_Type.tp_basicsize = pytalloc_BaseObject_size();
   36681             : 
   36682        2907 :         DNS_RPC_NAME_Type.tp_base = BaseObject_Type;
   36683        2907 :         DNS_RPC_NAME_Type.tp_basicsize = pytalloc_BaseObject_size();
   36684             : 
   36685        2907 :         DNS_RPC_NODE_Type.tp_base = BaseObject_Type;
   36686        2907 :         DNS_RPC_NODE_Type.tp_basicsize = pytalloc_BaseObject_size();
   36687             : 
   36688        2907 :         DNS_RPC_RECORD_SOA_Type.tp_base = BaseObject_Type;
   36689        2907 :         DNS_RPC_RECORD_SOA_Type.tp_basicsize = pytalloc_BaseObject_size();
   36690             : 
   36691        2907 :         DNS_RPC_RECORD_NAME_PREFERENCE_Type.tp_base = BaseObject_Type;
   36692        2907 :         DNS_RPC_RECORD_NAME_PREFERENCE_Type.tp_basicsize = pytalloc_BaseObject_size();
   36693             : 
   36694        2907 :         DNS_RPC_RECORD_STRING_Type.tp_base = BaseObject_Type;
   36695        2907 :         DNS_RPC_RECORD_STRING_Type.tp_basicsize = pytalloc_BaseObject_size();
   36696             : 
   36697        2907 :         DNS_RPC_RECORD_SRV_Type.tp_base = BaseObject_Type;
   36698        2907 :         DNS_RPC_RECORD_SRV_Type.tp_basicsize = pytalloc_BaseObject_size();
   36699             : 
   36700        2907 :         DNS_RPC_RECORD_DATA_Type.tp_base = BaseObject_Type;
   36701        2907 :         DNS_RPC_RECORD_DATA_Type.tp_basicsize = pytalloc_BaseObject_size();
   36702             : 
   36703        2907 :         DNS_RPC_RECORD_Type.tp_base = BaseObject_Type;
   36704        2907 :         DNS_RPC_RECORD_Type.tp_basicsize = pytalloc_BaseObject_size();
   36705             : 
   36706        2907 :         DNS_RPC_RECORD_BUF_Type.tp_base = BaseObject_Type;
   36707        2907 :         DNS_RPC_RECORD_BUF_Type.tp_basicsize = pytalloc_BaseObject_size();
   36708             : 
   36709        2907 :         IP4_ARRAY_Type.tp_base = BaseObject_Type;
   36710        2907 :         IP4_ARRAY_Type.tp_basicsize = pytalloc_BaseObject_size();
   36711             : 
   36712        2907 :         DNS_ADDR_Type.tp_base = BaseObject_Type;
   36713        2907 :         DNS_ADDR_Type.tp_basicsize = pytalloc_BaseObject_size();
   36714             : 
   36715        2907 :         DNS_ADDR_ARRAY_Type.tp_base = BaseObject_Type;
   36716        2907 :         DNS_ADDR_ARRAY_Type.tp_basicsize = pytalloc_BaseObject_size();
   36717             : 
   36718        2907 :         DNS_RPC_IP_VALIDATE_Type.tp_base = BaseObject_Type;
   36719        2907 :         DNS_RPC_IP_VALIDATE_Type.tp_basicsize = pytalloc_BaseObject_size();
   36720             : 
   36721        2907 :         DNS_RPC_SERVER_INFO_W2K_Type.tp_base = BaseObject_Type;
   36722        2907 :         DNS_RPC_SERVER_INFO_W2K_Type.tp_basicsize = pytalloc_BaseObject_size();
   36723             : 
   36724        2907 :         DNS_EXTENSION_Type.tp_base = BaseObject_Type;
   36725        2907 :         DNS_EXTENSION_Type.tp_basicsize = pytalloc_BaseObject_size();
   36726             : 
   36727        2907 :         DNS_RPC_SERVER_INFO_DOTNET_Type.tp_base = BaseObject_Type;
   36728        2907 :         DNS_RPC_SERVER_INFO_DOTNET_Type.tp_basicsize = pytalloc_BaseObject_size();
   36729             : 
   36730        2907 :         DNS_RPC_SERVER_INFO_LONGHORN_Type.tp_base = BaseObject_Type;
   36731        2907 :         DNS_RPC_SERVER_INFO_LONGHORN_Type.tp_basicsize = pytalloc_BaseObject_size();
   36732             : 
   36733        2907 :         DNS_RPC_DP_REPLICA_Type.tp_base = BaseObject_Type;
   36734        2907 :         DNS_RPC_DP_REPLICA_Type.tp_basicsize = pytalloc_BaseObject_size();
   36735             : 
   36736        2907 :         DNS_RPC_DP_INFO_Type.tp_base = BaseObject_Type;
   36737        2907 :         DNS_RPC_DP_INFO_Type.tp_basicsize = pytalloc_BaseObject_size();
   36738             : 
   36739        2907 :         DNS_RPC_DP_ENUM_Type.tp_base = BaseObject_Type;
   36740        2907 :         DNS_RPC_DP_ENUM_Type.tp_basicsize = pytalloc_BaseObject_size();
   36741             : 
   36742        2907 :         DNS_RPC_DP_LIST_Type.tp_base = BaseObject_Type;
   36743        2907 :         DNS_RPC_DP_LIST_Type.tp_basicsize = pytalloc_BaseObject_size();
   36744             : 
   36745        2907 :         DNS_RPC_ENLIST_DP_Type.tp_base = BaseObject_Type;
   36746        2907 :         DNS_RPC_ENLIST_DP_Type.tp_basicsize = pytalloc_BaseObject_size();
   36747             : 
   36748        2907 :         DNS_RPC_ZONE_CHANGE_DP_Type.tp_base = BaseObject_Type;
   36749        2907 :         DNS_RPC_ZONE_CHANGE_DP_Type.tp_basicsize = pytalloc_BaseObject_size();
   36750             : 
   36751        2907 :         DNS_RPC_ZONE_W2K_Type.tp_base = BaseObject_Type;
   36752        2907 :         DNS_RPC_ZONE_W2K_Type.tp_basicsize = pytalloc_BaseObject_size();
   36753             : 
   36754        2907 :         DNS_RPC_ZONE_DOTNET_Type.tp_base = BaseObject_Type;
   36755        2907 :         DNS_RPC_ZONE_DOTNET_Type.tp_basicsize = pytalloc_BaseObject_size();
   36756             : 
   36757        2907 :         DNS_RPC_ZONE_LIST_W2K_Type.tp_base = BaseObject_Type;
   36758        2907 :         DNS_RPC_ZONE_LIST_W2K_Type.tp_basicsize = pytalloc_BaseObject_size();
   36759             : 
   36760        2907 :         DNS_RPC_ZONE_LIST_DOTNET_Type.tp_base = BaseObject_Type;
   36761        2907 :         DNS_RPC_ZONE_LIST_DOTNET_Type.tp_basicsize = pytalloc_BaseObject_size();
   36762             : 
   36763        2907 :         DNS_RPC_ZONE_INFO_W2K_Type.tp_base = BaseObject_Type;
   36764        2907 :         DNS_RPC_ZONE_INFO_W2K_Type.tp_basicsize = pytalloc_BaseObject_size();
   36765             : 
   36766        2907 :         DNS_RPC_ZONE_INFO_DOTNET_Type.tp_base = BaseObject_Type;
   36767        2907 :         DNS_RPC_ZONE_INFO_DOTNET_Type.tp_basicsize = pytalloc_BaseObject_size();
   36768             : 
   36769        2907 :         DNS_RPC_ZONE_INFO_LONGHORN_Type.tp_base = BaseObject_Type;
   36770        2907 :         DNS_RPC_ZONE_INFO_LONGHORN_Type.tp_basicsize = pytalloc_BaseObject_size();
   36771             : 
   36772        2907 :         DNS_RPC_ZONE_SECONDARIES_W2K_Type.tp_base = BaseObject_Type;
   36773        2907 :         DNS_RPC_ZONE_SECONDARIES_W2K_Type.tp_basicsize = pytalloc_BaseObject_size();
   36774             : 
   36775        2907 :         DNS_RPC_ZONE_SECONDARIES_DOTNET_Type.tp_base = BaseObject_Type;
   36776        2907 :         DNS_RPC_ZONE_SECONDARIES_DOTNET_Type.tp_basicsize = pytalloc_BaseObject_size();
   36777             : 
   36778        2907 :         DNS_RPC_ZONE_SECONDARIES_LONGHORN_Type.tp_base = BaseObject_Type;
   36779        2907 :         DNS_RPC_ZONE_SECONDARIES_LONGHORN_Type.tp_basicsize = pytalloc_BaseObject_size();
   36780             : 
   36781        2907 :         DNS_RPC_ZONE_DATABASE_W2K_Type.tp_base = BaseObject_Type;
   36782        2907 :         DNS_RPC_ZONE_DATABASE_W2K_Type.tp_basicsize = pytalloc_BaseObject_size();
   36783             : 
   36784        2907 :         DNS_RPC_ZONE_DATABASE_DOTNET_Type.tp_base = BaseObject_Type;
   36785        2907 :         DNS_RPC_ZONE_DATABASE_DOTNET_Type.tp_basicsize = pytalloc_BaseObject_size();
   36786             : 
   36787        2907 :         DNS_RPC_ZONE_CREATE_INFO_W2K_Type.tp_base = BaseObject_Type;
   36788        2907 :         DNS_RPC_ZONE_CREATE_INFO_W2K_Type.tp_basicsize = pytalloc_BaseObject_size();
   36789             : 
   36790        2907 :         DNS_RPC_ZONE_CREATE_INFO_DOTNET_Type.tp_base = BaseObject_Type;
   36791        2907 :         DNS_RPC_ZONE_CREATE_INFO_DOTNET_Type.tp_basicsize = pytalloc_BaseObject_size();
   36792             : 
   36793        2907 :         DNS_RPC_ZONE_CREATE_INFO_LONGHORN_Type.tp_base = BaseObject_Type;
   36794        2907 :         DNS_RPC_ZONE_CREATE_INFO_LONGHORN_Type.tp_basicsize = pytalloc_BaseObject_size();
   36795             : 
   36796        2907 :         DNS_RPC_ZONE_EXPORT_INFO_Type.tp_base = BaseObject_Type;
   36797        2907 :         DNS_RPC_ZONE_EXPORT_INFO_Type.tp_basicsize = pytalloc_BaseObject_size();
   36798             : 
   36799        2907 :         DNS_RPC_ENUM_ZONES_FILTER_Type.tp_base = BaseObject_Type;
   36800        2907 :         DNS_RPC_ENUM_ZONES_FILTER_Type.tp_basicsize = pytalloc_BaseObject_size();
   36801             : 
   36802        2907 :         DNS_RPC_FORWARDERS_W2K_Type.tp_base = BaseObject_Type;
   36803        2907 :         DNS_RPC_FORWARDERS_W2K_Type.tp_basicsize = pytalloc_BaseObject_size();
   36804             : 
   36805        2907 :         DNS_RPC_FORWARDERS_DOTNET_Type.tp_base = BaseObject_Type;
   36806        2907 :         DNS_RPC_FORWARDERS_DOTNET_Type.tp_basicsize = pytalloc_BaseObject_size();
   36807             : 
   36808        2907 :         DNS_RPC_FORWARDERS_LONGHORN_Type.tp_base = BaseObject_Type;
   36809        2907 :         DNS_RPC_FORWARDERS_LONGHORN_Type.tp_basicsize = pytalloc_BaseObject_size();
   36810             : 
   36811        2907 :         DNS_RPC_AUTOCONFIGURE_Type.tp_base = BaseObject_Type;
   36812        2907 :         DNS_RPC_AUTOCONFIGURE_Type.tp_basicsize = pytalloc_BaseObject_size();
   36813             : 
   36814        2907 :         DNSSRV_STAT_HEADER_Type.tp_base = BaseObject_Type;
   36815        2907 :         DNSSRV_STAT_HEADER_Type.tp_basicsize = pytalloc_BaseObject_size();
   36816             : 
   36817        2907 :         DNSSRV_STAT_Type.tp_base = BaseObject_Type;
   36818        2907 :         DNSSRV_STAT_Type.tp_basicsize = pytalloc_BaseObject_size();
   36819             : 
   36820        2907 :         DNSSRV_RPC_UNION_Type.tp_base = BaseObject_Type;
   36821        2907 :         DNSSRV_RPC_UNION_Type.tp_basicsize = pytalloc_BaseObject_size();
   36822             : 
   36823        2907 :         DNS_RPC_RECORDS_Type.tp_base = BaseObject_Type;
   36824        2907 :         DNS_RPC_RECORDS_Type.tp_basicsize = pytalloc_BaseObject_size();
   36825             : 
   36826        2907 :         DNS_RPC_RECORDS_ARRAY_Type.tp_base = BaseObject_Type;
   36827        2907 :         DNS_RPC_RECORDS_ARRAY_Type.tp_basicsize = pytalloc_BaseObject_size();
   36828             : 
   36829        2907 :         DnssrvOperation_Type.tp_base = BaseObject_Type;
   36830        2907 :         DnssrvOperation_Type.tp_basicsize = pytalloc_BaseObject_size();
   36831             : 
   36832        2907 :         DnssrvQuery_Type.tp_base = BaseObject_Type;
   36833        2907 :         DnssrvQuery_Type.tp_basicsize = pytalloc_BaseObject_size();
   36834             : 
   36835        2907 :         DnssrvComplexOperation_Type.tp_base = BaseObject_Type;
   36836        2907 :         DnssrvComplexOperation_Type.tp_basicsize = pytalloc_BaseObject_size();
   36837             : 
   36838        2907 :         DnssrvEnumRecords_Type.tp_base = BaseObject_Type;
   36839        2907 :         DnssrvEnumRecords_Type.tp_basicsize = pytalloc_BaseObject_size();
   36840             : 
   36841        2907 :         DnssrvUpdateRecord_Type.tp_base = BaseObject_Type;
   36842        2907 :         DnssrvUpdateRecord_Type.tp_basicsize = pytalloc_BaseObject_size();
   36843             : 
   36844        2907 :         DnssrvOperation2_Type.tp_base = BaseObject_Type;
   36845        2907 :         DnssrvOperation2_Type.tp_basicsize = pytalloc_BaseObject_size();
   36846             : 
   36847        2907 :         DnssrvQuery2_Type.tp_base = BaseObject_Type;
   36848        2907 :         DnssrvQuery2_Type.tp_basicsize = pytalloc_BaseObject_size();
   36849             : 
   36850        2907 :         DnssrvComplexOperation2_Type.tp_base = BaseObject_Type;
   36851        2907 :         DnssrvComplexOperation2_Type.tp_basicsize = pytalloc_BaseObject_size();
   36852             : 
   36853        2907 :         DnssrvEnumRecords2_Type.tp_base = BaseObject_Type;
   36854        2907 :         DnssrvEnumRecords2_Type.tp_basicsize = pytalloc_BaseObject_size();
   36855             : 
   36856        2907 :         DnssrvUpdateRecord2_Type.tp_base = BaseObject_Type;
   36857        2907 :         DnssrvUpdateRecord2_Type.tp_basicsize = pytalloc_BaseObject_size();
   36858             : 
   36859        2907 :         dnsserver_InterfaceType.tp_base = ClientConnection_Type;
   36860             : 
   36861        2907 :         dnsserver_SyntaxType.tp_base = ndr_syntax_id_Type;
   36862        2907 :         dnsserver_SyntaxType.tp_basicsize = pytalloc_BaseObject_size();
   36863             : 
   36864        2907 :         if (PyType_Ready(&DNS_RPC_BUFFER_Type) < 0)
   36865           0 :                 goto out;
   36866        2907 :         if (PyType_Ready(&DNS_RPC_UTF8_STRING_LIST_Type) < 0)
   36867           0 :                 goto out;
   36868        2907 :         if (PyType_Ready(&DNS_RPC_NAME_AND_PARAM_Type) < 0)
   36869           0 :                 goto out;
   36870        2907 :         if (PyType_Ready(&DNS_RPC_NAME_Type) < 0)
   36871           0 :                 goto out;
   36872        2907 :         if (PyType_Ready(&DNS_RPC_NODE_Type) < 0)
   36873           0 :                 goto out;
   36874        2907 :         if (PyType_Ready(&DNS_RPC_RECORD_SOA_Type) < 0)
   36875           0 :                 goto out;
   36876        2907 :         if (PyType_Ready(&DNS_RPC_RECORD_NAME_PREFERENCE_Type) < 0)
   36877           0 :                 goto out;
   36878        2907 :         if (PyType_Ready(&DNS_RPC_RECORD_STRING_Type) < 0)
   36879           0 :                 goto out;
   36880        2907 :         if (PyType_Ready(&DNS_RPC_RECORD_SRV_Type) < 0)
   36881           0 :                 goto out;
   36882        2907 :         if (PyType_Ready(&DNS_RPC_RECORD_DATA_Type) < 0)
   36883           0 :                 goto out;
   36884        2907 :         if (PyType_Ready(&DNS_RPC_RECORD_Type) < 0)
   36885           0 :                 goto out;
   36886        2907 :         if (PyType_Ready(&DNS_RPC_RECORD_BUF_Type) < 0)
   36887           0 :                 goto out;
   36888        2907 :         if (PyType_Ready(&IP4_ARRAY_Type) < 0)
   36889           0 :                 goto out;
   36890        2907 :         if (PyType_Ready(&DNS_ADDR_Type) < 0)
   36891           0 :                 goto out;
   36892        2907 :         if (PyType_Ready(&DNS_ADDR_ARRAY_Type) < 0)
   36893           0 :                 goto out;
   36894        2907 :         if (PyType_Ready(&DNS_RPC_IP_VALIDATE_Type) < 0)
   36895           0 :                 goto out;
   36896        2907 :         if (PyType_Ready(&DNS_RPC_SERVER_INFO_W2K_Type) < 0)
   36897           0 :                 goto out;
   36898        2907 :         if (PyType_Ready(&DNS_EXTENSION_Type) < 0)
   36899           0 :                 goto out;
   36900        2907 :         if (PyType_Ready(&DNS_RPC_SERVER_INFO_DOTNET_Type) < 0)
   36901           0 :                 goto out;
   36902        2907 :         if (PyType_Ready(&DNS_RPC_SERVER_INFO_LONGHORN_Type) < 0)
   36903           0 :                 goto out;
   36904        2907 :         if (PyType_Ready(&DNS_RPC_DP_REPLICA_Type) < 0)
   36905           0 :                 goto out;
   36906        2907 :         if (PyType_Ready(&DNS_RPC_DP_INFO_Type) < 0)
   36907           0 :                 goto out;
   36908        2907 :         if (PyType_Ready(&DNS_RPC_DP_ENUM_Type) < 0)
   36909           0 :                 goto out;
   36910        2907 :         if (PyType_Ready(&DNS_RPC_DP_LIST_Type) < 0)
   36911           0 :                 goto out;
   36912        2907 :         if (PyType_Ready(&DNS_RPC_ENLIST_DP_Type) < 0)
   36913           0 :                 goto out;
   36914        2907 :         if (PyType_Ready(&DNS_RPC_ZONE_CHANGE_DP_Type) < 0)
   36915           0 :                 goto out;
   36916        2907 :         if (PyType_Ready(&DNS_RPC_ZONE_W2K_Type) < 0)
   36917           0 :                 goto out;
   36918        2907 :         if (PyType_Ready(&DNS_RPC_ZONE_DOTNET_Type) < 0)
   36919           0 :                 goto out;
   36920        2907 :         if (PyType_Ready(&DNS_RPC_ZONE_LIST_W2K_Type) < 0)
   36921           0 :                 goto out;
   36922        2907 :         if (PyType_Ready(&DNS_RPC_ZONE_LIST_DOTNET_Type) < 0)
   36923           0 :                 goto out;
   36924        2907 :         if (PyType_Ready(&DNS_RPC_ZONE_INFO_W2K_Type) < 0)
   36925           0 :                 goto out;
   36926        2907 :         if (PyType_Ready(&DNS_RPC_ZONE_INFO_DOTNET_Type) < 0)
   36927           0 :                 goto out;
   36928        2907 :         if (PyType_Ready(&DNS_RPC_ZONE_INFO_LONGHORN_Type) < 0)
   36929           0 :                 goto out;
   36930        2907 :         if (PyType_Ready(&DNS_RPC_ZONE_SECONDARIES_W2K_Type) < 0)
   36931           0 :                 goto out;
   36932        2907 :         if (PyType_Ready(&DNS_RPC_ZONE_SECONDARIES_DOTNET_Type) < 0)
   36933           0 :                 goto out;
   36934        2907 :         if (PyType_Ready(&DNS_RPC_ZONE_SECONDARIES_LONGHORN_Type) < 0)
   36935           0 :                 goto out;
   36936        2907 :         if (PyType_Ready(&DNS_RPC_ZONE_DATABASE_W2K_Type) < 0)
   36937           0 :                 goto out;
   36938        2907 :         if (PyType_Ready(&DNS_RPC_ZONE_DATABASE_DOTNET_Type) < 0)
   36939           0 :                 goto out;
   36940        2907 :         if (PyType_Ready(&DNS_RPC_ZONE_CREATE_INFO_W2K_Type) < 0)
   36941           0 :                 goto out;
   36942        2907 :         if (PyType_Ready(&DNS_RPC_ZONE_CREATE_INFO_DOTNET_Type) < 0)
   36943           0 :                 goto out;
   36944        2907 :         if (PyType_Ready(&DNS_RPC_ZONE_CREATE_INFO_LONGHORN_Type) < 0)
   36945           0 :                 goto out;
   36946        2907 :         if (PyType_Ready(&DNS_RPC_ZONE_EXPORT_INFO_Type) < 0)
   36947           0 :                 goto out;
   36948        2907 :         if (PyType_Ready(&DNS_RPC_ENUM_ZONES_FILTER_Type) < 0)
   36949           0 :                 goto out;
   36950        2907 :         if (PyType_Ready(&DNS_RPC_FORWARDERS_W2K_Type) < 0)
   36951           0 :                 goto out;
   36952        2907 :         if (PyType_Ready(&DNS_RPC_FORWARDERS_DOTNET_Type) < 0)
   36953           0 :                 goto out;
   36954        2907 :         if (PyType_Ready(&DNS_RPC_FORWARDERS_LONGHORN_Type) < 0)
   36955           0 :                 goto out;
   36956        2907 :         if (PyType_Ready(&DNS_RPC_AUTOCONFIGURE_Type) < 0)
   36957           0 :                 goto out;
   36958        2907 :         if (PyType_Ready(&DNSSRV_STAT_HEADER_Type) < 0)
   36959           0 :                 goto out;
   36960        2907 :         if (PyType_Ready(&DNSSRV_STAT_Type) < 0)
   36961           0 :                 goto out;
   36962        2907 :         if (PyType_Ready(&DNSSRV_RPC_UNION_Type) < 0)
   36963           0 :                 goto out;
   36964        2907 :         if (PyType_Ready(&DNS_RPC_RECORDS_Type) < 0)
   36965           0 :                 goto out;
   36966        2907 :         if (PyType_Ready(&DNS_RPC_RECORDS_ARRAY_Type) < 0)
   36967           0 :                 goto out;
   36968        2907 :         if (PyType_Ready(&DnssrvOperation_Type) < 0)
   36969           0 :                 goto out;
   36970        2907 :         if (PyType_Ready(&DnssrvQuery_Type) < 0)
   36971           0 :                 goto out;
   36972        2907 :         if (PyType_Ready(&DnssrvComplexOperation_Type) < 0)
   36973           0 :                 goto out;
   36974        2907 :         if (PyType_Ready(&DnssrvEnumRecords_Type) < 0)
   36975           0 :                 goto out;
   36976        2907 :         if (PyType_Ready(&DnssrvUpdateRecord_Type) < 0)
   36977           0 :                 goto out;
   36978        2907 :         if (PyType_Ready(&DnssrvOperation2_Type) < 0)
   36979           0 :                 goto out;
   36980        2907 :         if (PyType_Ready(&DnssrvQuery2_Type) < 0)
   36981           0 :                 goto out;
   36982        2907 :         if (PyType_Ready(&DnssrvComplexOperation2_Type) < 0)
   36983           0 :                 goto out;
   36984        2907 :         if (PyType_Ready(&DnssrvEnumRecords2_Type) < 0)
   36985           0 :                 goto out;
   36986        2907 :         if (PyType_Ready(&DnssrvUpdateRecord2_Type) < 0)
   36987           0 :                 goto out;
   36988        2907 :         if (PyType_Ready(&dnsserver_InterfaceType) < 0)
   36989           0 :                 goto out;
   36990        2907 :         if (PyType_Ready(&dnsserver_SyntaxType) < 0)
   36991           0 :                 goto out;
   36992        2907 :         if (!PyInterface_AddNdrRpcMethods(&dnsserver_InterfaceType, py_ndr_dnsserver_methods))
   36993           0 :                 return NULL;
   36994             : 
   36995             : #ifdef PY_DNS_RPC_BUFFER_PATCH
   36996             :         PY_DNS_RPC_BUFFER_PATCH(&DNS_RPC_BUFFER_Type);
   36997             : #endif
   36998             : #ifdef PY_DNS_RPC_UTF8_STRING_LIST_PATCH
   36999             :         PY_DNS_RPC_UTF8_STRING_LIST_PATCH(&DNS_RPC_UTF8_STRING_LIST_Type);
   37000             : #endif
   37001             : #ifdef PY_DNS_RPC_NAME_AND_PARAM_PATCH
   37002             :         PY_DNS_RPC_NAME_AND_PARAM_PATCH(&DNS_RPC_NAME_AND_PARAM_Type);
   37003             : #endif
   37004             : #ifdef PY_DNS_RPC_NAME_PATCH
   37005             :         PY_DNS_RPC_NAME_PATCH(&DNS_RPC_NAME_Type);
   37006             : #endif
   37007             : #ifdef PY_DNS_RPC_NODE_PATCH
   37008             :         PY_DNS_RPC_NODE_PATCH(&DNS_RPC_NODE_Type);
   37009             : #endif
   37010             : #ifdef PY_DNS_RPC_RECORD_SOA_PATCH
   37011             :         PY_DNS_RPC_RECORD_SOA_PATCH(&DNS_RPC_RECORD_SOA_Type);
   37012             : #endif
   37013             : #ifdef PY_DNS_RPC_RECORD_NAME_PREFERENCE_PATCH
   37014             :         PY_DNS_RPC_RECORD_NAME_PREFERENCE_PATCH(&DNS_RPC_RECORD_NAME_PREFERENCE_Type);
   37015             : #endif
   37016             : #ifdef PY_DNS_RPC_RECORD_STRING_PATCH
   37017             :         PY_DNS_RPC_RECORD_STRING_PATCH(&DNS_RPC_RECORD_STRING_Type);
   37018             : #endif
   37019             : #ifdef PY_DNS_RPC_RECORD_SRV_PATCH
   37020             :         PY_DNS_RPC_RECORD_SRV_PATCH(&DNS_RPC_RECORD_SRV_Type);
   37021             : #endif
   37022             : #ifdef PY_DNS_RPC_RECORD_DATA_PATCH
   37023             :         PY_DNS_RPC_RECORD_DATA_PATCH(&DNS_RPC_RECORD_DATA_Type);
   37024             : #endif
   37025             : #ifdef PY_DNS_RPC_RECORD_PATCH
   37026             :         PY_DNS_RPC_RECORD_PATCH(&DNS_RPC_RECORD_Type);
   37027             : #endif
   37028             : #ifdef PY_DNS_RPC_RECORD_BUF_PATCH
   37029             :         PY_DNS_RPC_RECORD_BUF_PATCH(&DNS_RPC_RECORD_BUF_Type);
   37030             : #endif
   37031             : #ifdef PY_IP4_ARRAY_PATCH
   37032             :         PY_IP4_ARRAY_PATCH(&IP4_ARRAY_Type);
   37033             : #endif
   37034             : #ifdef PY_DNS_ADDR_PATCH
   37035             :         PY_DNS_ADDR_PATCH(&DNS_ADDR_Type);
   37036             : #endif
   37037             : #ifdef PY_DNS_ADDR_ARRAY_PATCH
   37038             :         PY_DNS_ADDR_ARRAY_PATCH(&DNS_ADDR_ARRAY_Type);
   37039             : #endif
   37040             : #ifdef PY_DNS_RPC_IP_VALIDATE_PATCH
   37041             :         PY_DNS_RPC_IP_VALIDATE_PATCH(&DNS_RPC_IP_VALIDATE_Type);
   37042             : #endif
   37043             : #ifdef PY_DNS_RPC_SERVER_INFO_W2K_PATCH
   37044             :         PY_DNS_RPC_SERVER_INFO_W2K_PATCH(&DNS_RPC_SERVER_INFO_W2K_Type);
   37045             : #endif
   37046             : #ifdef PY_DNS_EXTENSION_PATCH
   37047             :         PY_DNS_EXTENSION_PATCH(&DNS_EXTENSION_Type);
   37048             : #endif
   37049             : #ifdef PY_DNS_RPC_SERVER_INFO_DOTNET_PATCH
   37050             :         PY_DNS_RPC_SERVER_INFO_DOTNET_PATCH(&DNS_RPC_SERVER_INFO_DOTNET_Type);
   37051             : #endif
   37052             : #ifdef PY_DNS_RPC_SERVER_INFO_LONGHORN_PATCH
   37053             :         PY_DNS_RPC_SERVER_INFO_LONGHORN_PATCH(&DNS_RPC_SERVER_INFO_LONGHORN_Type);
   37054             : #endif
   37055             : #ifdef PY_DNS_RPC_DP_REPLICA_PATCH
   37056             :         PY_DNS_RPC_DP_REPLICA_PATCH(&DNS_RPC_DP_REPLICA_Type);
   37057             : #endif
   37058             : #ifdef PY_DNS_RPC_DP_INFO_PATCH
   37059             :         PY_DNS_RPC_DP_INFO_PATCH(&DNS_RPC_DP_INFO_Type);
   37060             : #endif
   37061             : #ifdef PY_DNS_RPC_DP_ENUM_PATCH
   37062             :         PY_DNS_RPC_DP_ENUM_PATCH(&DNS_RPC_DP_ENUM_Type);
   37063             : #endif
   37064             : #ifdef PY_DNS_RPC_DP_LIST_PATCH
   37065             :         PY_DNS_RPC_DP_LIST_PATCH(&DNS_RPC_DP_LIST_Type);
   37066             : #endif
   37067             : #ifdef PY_DNS_RPC_ENLIST_DP_PATCH
   37068             :         PY_DNS_RPC_ENLIST_DP_PATCH(&DNS_RPC_ENLIST_DP_Type);
   37069             : #endif
   37070             : #ifdef PY_DNS_RPC_ZONE_CHANGE_DP_PATCH
   37071             :         PY_DNS_RPC_ZONE_CHANGE_DP_PATCH(&DNS_RPC_ZONE_CHANGE_DP_Type);
   37072             : #endif
   37073             : #ifdef PY_DNS_RPC_ZONE_W2K_PATCH
   37074             :         PY_DNS_RPC_ZONE_W2K_PATCH(&DNS_RPC_ZONE_W2K_Type);
   37075             : #endif
   37076             : #ifdef PY_DNS_RPC_ZONE_DOTNET_PATCH
   37077             :         PY_DNS_RPC_ZONE_DOTNET_PATCH(&DNS_RPC_ZONE_DOTNET_Type);
   37078             : #endif
   37079             : #ifdef PY_DNS_RPC_ZONE_LIST_W2K_PATCH
   37080             :         PY_DNS_RPC_ZONE_LIST_W2K_PATCH(&DNS_RPC_ZONE_LIST_W2K_Type);
   37081             : #endif
   37082             : #ifdef PY_DNS_RPC_ZONE_LIST_DOTNET_PATCH
   37083             :         PY_DNS_RPC_ZONE_LIST_DOTNET_PATCH(&DNS_RPC_ZONE_LIST_DOTNET_Type);
   37084             : #endif
   37085             : #ifdef PY_DNS_RPC_ZONE_INFO_W2K_PATCH
   37086             :         PY_DNS_RPC_ZONE_INFO_W2K_PATCH(&DNS_RPC_ZONE_INFO_W2K_Type);
   37087             : #endif
   37088             : #ifdef PY_DNS_RPC_ZONE_INFO_DOTNET_PATCH
   37089             :         PY_DNS_RPC_ZONE_INFO_DOTNET_PATCH(&DNS_RPC_ZONE_INFO_DOTNET_Type);
   37090             : #endif
   37091             : #ifdef PY_DNS_RPC_ZONE_INFO_LONGHORN_PATCH
   37092             :         PY_DNS_RPC_ZONE_INFO_LONGHORN_PATCH(&DNS_RPC_ZONE_INFO_LONGHORN_Type);
   37093             : #endif
   37094             : #ifdef PY_DNS_RPC_ZONE_SECONDARIES_W2K_PATCH
   37095             :         PY_DNS_RPC_ZONE_SECONDARIES_W2K_PATCH(&DNS_RPC_ZONE_SECONDARIES_W2K_Type);
   37096             : #endif
   37097             : #ifdef PY_DNS_RPC_ZONE_SECONDARIES_DOTNET_PATCH
   37098             :         PY_DNS_RPC_ZONE_SECONDARIES_DOTNET_PATCH(&DNS_RPC_ZONE_SECONDARIES_DOTNET_Type);
   37099             : #endif
   37100             : #ifdef PY_DNS_RPC_ZONE_SECONDARIES_LONGHORN_PATCH
   37101             :         PY_DNS_RPC_ZONE_SECONDARIES_LONGHORN_PATCH(&DNS_RPC_ZONE_SECONDARIES_LONGHORN_Type);
   37102             : #endif
   37103             : #ifdef PY_DNS_RPC_ZONE_DATABASE_W2K_PATCH
   37104             :         PY_DNS_RPC_ZONE_DATABASE_W2K_PATCH(&DNS_RPC_ZONE_DATABASE_W2K_Type);
   37105             : #endif
   37106             : #ifdef PY_DNS_RPC_ZONE_DATABASE_DOTNET_PATCH
   37107             :         PY_DNS_RPC_ZONE_DATABASE_DOTNET_PATCH(&DNS_RPC_ZONE_DATABASE_DOTNET_Type);
   37108             : #endif
   37109             : #ifdef PY_DNS_RPC_ZONE_CREATE_INFO_W2K_PATCH
   37110             :         PY_DNS_RPC_ZONE_CREATE_INFO_W2K_PATCH(&DNS_RPC_ZONE_CREATE_INFO_W2K_Type);
   37111             : #endif
   37112             : #ifdef PY_DNS_RPC_ZONE_CREATE_INFO_DOTNET_PATCH
   37113             :         PY_DNS_RPC_ZONE_CREATE_INFO_DOTNET_PATCH(&DNS_RPC_ZONE_CREATE_INFO_DOTNET_Type);
   37114             : #endif
   37115             : #ifdef PY_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_PATCH
   37116             :         PY_DNS_RPC_ZONE_CREATE_INFO_LONGHORN_PATCH(&DNS_RPC_ZONE_CREATE_INFO_LONGHORN_Type);
   37117             : #endif
   37118             : #ifdef PY_DNS_RPC_ZONE_EXPORT_INFO_PATCH
   37119             :         PY_DNS_RPC_ZONE_EXPORT_INFO_PATCH(&DNS_RPC_ZONE_EXPORT_INFO_Type);
   37120             : #endif
   37121             : #ifdef PY_DNS_RPC_ENUM_ZONES_FILTER_PATCH
   37122             :         PY_DNS_RPC_ENUM_ZONES_FILTER_PATCH(&DNS_RPC_ENUM_ZONES_FILTER_Type);
   37123             : #endif
   37124             : #ifdef PY_DNS_RPC_FORWARDERS_W2K_PATCH
   37125             :         PY_DNS_RPC_FORWARDERS_W2K_PATCH(&DNS_RPC_FORWARDERS_W2K_Type);
   37126             : #endif
   37127             : #ifdef PY_DNS_RPC_FORWARDERS_DOTNET_PATCH
   37128             :         PY_DNS_RPC_FORWARDERS_DOTNET_PATCH(&DNS_RPC_FORWARDERS_DOTNET_Type);
   37129             : #endif
   37130             : #ifdef PY_DNS_RPC_FORWARDERS_LONGHORN_PATCH
   37131             :         PY_DNS_RPC_FORWARDERS_LONGHORN_PATCH(&DNS_RPC_FORWARDERS_LONGHORN_Type);
   37132             : #endif
   37133             : #ifdef PY_DNS_RPC_AUTOCONFIGURE_PATCH
   37134             :         PY_DNS_RPC_AUTOCONFIGURE_PATCH(&DNS_RPC_AUTOCONFIGURE_Type);
   37135             : #endif
   37136             : #ifdef PY_DNSSRV_STAT_HEADER_PATCH
   37137             :         PY_DNSSRV_STAT_HEADER_PATCH(&DNSSRV_STAT_HEADER_Type);
   37138             : #endif
   37139             : #ifdef PY_DNSSRV_STAT_PATCH
   37140             :         PY_DNSSRV_STAT_PATCH(&DNSSRV_STAT_Type);
   37141             : #endif
   37142             : #ifdef PY_DNSSRV_RPC_UNION_PATCH
   37143             :         PY_DNSSRV_RPC_UNION_PATCH(&DNSSRV_RPC_UNION_Type);
   37144             : #endif
   37145             : #ifdef PY_DNS_RPC_RECORDS_PATCH
   37146             :         PY_DNS_RPC_RECORDS_PATCH(&DNS_RPC_RECORDS_Type);
   37147             : #endif
   37148             : #ifdef PY_DNS_RPC_RECORDS_ARRAY_PATCH
   37149             :         PY_DNS_RPC_RECORDS_ARRAY_PATCH(&DNS_RPC_RECORDS_ARRAY_Type);
   37150             : #endif
   37151             : #ifdef PY_DNSSRVOPERATION_PATCH
   37152             :         PY_DNSSRVOPERATION_PATCH(&DnssrvOperation_Type);
   37153             : #endif
   37154             : #ifdef PY_DNSSRVQUERY_PATCH
   37155             :         PY_DNSSRVQUERY_PATCH(&DnssrvQuery_Type);
   37156             : #endif
   37157             : #ifdef PY_DNSSRVCOMPLEXOPERATION_PATCH
   37158             :         PY_DNSSRVCOMPLEXOPERATION_PATCH(&DnssrvComplexOperation_Type);
   37159             : #endif
   37160             : #ifdef PY_DNSSRVENUMRECORDS_PATCH
   37161             :         PY_DNSSRVENUMRECORDS_PATCH(&DnssrvEnumRecords_Type);
   37162             : #endif
   37163             : #ifdef PY_DNSSRVUPDATERECORD_PATCH
   37164             :         PY_DNSSRVUPDATERECORD_PATCH(&DnssrvUpdateRecord_Type);
   37165             : #endif
   37166             : #ifdef PY_DNSSRVOPERATION2_PATCH
   37167             :         PY_DNSSRVOPERATION2_PATCH(&DnssrvOperation2_Type);
   37168             : #endif
   37169             : #ifdef PY_DNSSRVQUERY2_PATCH
   37170             :         PY_DNSSRVQUERY2_PATCH(&DnssrvQuery2_Type);
   37171             : #endif
   37172             : #ifdef PY_DNSSRVCOMPLEXOPERATION2_PATCH
   37173             :         PY_DNSSRVCOMPLEXOPERATION2_PATCH(&DnssrvComplexOperation2_Type);
   37174             : #endif
   37175             : #ifdef PY_DNSSRVENUMRECORDS2_PATCH
   37176             :         PY_DNSSRVENUMRECORDS2_PATCH(&DnssrvEnumRecords2_Type);
   37177             : #endif
   37178             : #ifdef PY_DNSSRVUPDATERECORD2_PATCH
   37179             :         PY_DNSSRVUPDATERECORD2_PATCH(&DnssrvUpdateRecord2_Type);
   37180             : #endif
   37181             : #ifdef PY_DNSSERVER_PATCH
   37182             :         PY_DNSSERVER_PATCH(&dnsserver_InterfaceType);
   37183             : #endif
   37184             : #ifdef PY_DNSSERVER_ABSTRACT_SYNTAX_PATCH
   37185             :         PY_DNSSERVER_ABSTRACT_SYNTAX_PATCH(&dnsserver_SyntaxType);
   37186             : #endif
   37187             : #ifdef PY_ABSTRACT_SYNTAX_PATCH
   37188             :         PY_ABSTRACT_SYNTAX_PATCH(&dnsserver_SyntaxType);
   37189             : #endif
   37190             : 
   37191        2907 :         m = PyModule_Create(&moduledef);
   37192        2907 :         if (m == NULL)
   37193           0 :                 goto out;
   37194             : 
   37195        2907 :         PyModule_AddObject(m, "DNS_RPC_USE_TCPIP", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_USE_TCPIP)));
   37196        2907 :         PyModule_AddObject(m, "DNS_RPC_USE_NAMED_PIPE", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_USE_NAMED_PIPE)));
   37197        2907 :         PyModule_AddObject(m, "DNS_RPC_USE_LPC", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_USE_LPC)));
   37198        2907 :         PyModule_AddObject(m, "DNS_RPC_USE_ALL_PROTOCOLS", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_USE_ALL_PROTOCOLS)));
   37199        2907 :         PyModule_AddObject(m, "DNS_CLIENT_VERSION_W2K", PyLong_FromUnsignedLongLong((uint32_t)(DNS_CLIENT_VERSION_W2K)));
   37200        2907 :         PyModule_AddObject(m, "DNS_CLIENT_VERSION_DOTNET", PyLong_FromUnsignedLongLong((uint32_t)(DNS_CLIENT_VERSION_DOTNET)));
   37201        2907 :         PyModule_AddObject(m, "DNS_CLIENT_VERSION_LONGHORN", PyLong_FromUnsignedLongLong((uint32_t)(DNS_CLIENT_VERSION_LONGHORN)));
   37202        2907 :         PyModule_AddObject(m, "DNS_IPVAL_DNS_SERVERS", PyLong_FromUnsignedLongLong((uint32_t)(DNS_IPVAL_DNS_SERVERS)));
   37203        2907 :         PyModule_AddObject(m, "DNS_IPVAL_DNS_ROOTHINTS", PyLong_FromUnsignedLongLong((uint32_t)(DNS_IPVAL_DNS_ROOTHINTS)));
   37204        2907 :         PyModule_AddObject(m, "DNS_IPVAL_DNS_FORWARDERS", PyLong_FromUnsignedLongLong((uint32_t)(DNS_IPVAL_DNS_FORWARDERS)));
   37205        2907 :         PyModule_AddObject(m, "DNS_IPVAL_DNS_ZONE_MASTERS", PyLong_FromUnsignedLongLong((uint32_t)(DNS_IPVAL_DNS_ZONE_MASTERS)));
   37206        2907 :         PyModule_AddObject(m, "DNS_IPVAL_DNS_DELEGATIONS", PyLong_FromUnsignedLongLong((uint32_t)(DNS_IPVAL_DNS_DELEGATIONS)));
   37207        2907 :         PyModule_AddObject(m, "ERROR_SUCCESS", PyLong_FromUnsignedLongLong((uint32_t)(ERROR_SUCCESS)));
   37208        2907 :         PyModule_AddObject(m, "DNS_IPVAL_INVALID_ADDR", PyLong_FromUnsignedLongLong((uint32_t)(DNS_IPVAL_INVALID_ADDR)));
   37209        2907 :         PyModule_AddObject(m, "DNS_IPVAL_UNREACHABLE", PyLong_FromUnsignedLongLong((uint32_t)(DNS_IPVAL_UNREACHABLE)));
   37210        2907 :         PyModule_AddObject(m, "DNS_IPVAL_NO_RESPONSE", PyLong_FromUnsignedLongLong((uint32_t)(DNS_IPVAL_NO_RESPONSE)));
   37211        2907 :         PyModule_AddObject(m, "DNS_IPVAL_NOT_AUTH_FOR_ZONE", PyLong_FromUnsignedLongLong((uint32_t)(DNS_IPVAL_NOT_AUTH_FOR_ZONE)));
   37212        2907 :         PyModule_AddObject(m, "DNS_IPVAL_UNKNOWN_ERROR", PyLong_FromUnsignedLongLong((uint32_t)(DNS_IPVAL_UNKNOWN_ERROR)));
   37213        2907 :         PyModule_AddObject(m, "DNS_IPVAL_NO_TCP", PyLong_FromUnsignedLongLong((uint32_t)(DNS_IPVAL_NO_TCP)));
   37214        2907 :         PyModule_AddObject(m, "DNS_BOOT_METHOD_UNINITIALIZED", PyLong_FromLong((uint16_t)(DNS_BOOT_METHOD_UNINITIALIZED)));
   37215        2907 :         PyModule_AddObject(m, "DNS_BOOT_METHOD_FILE", PyLong_FromLong((uint16_t)(DNS_BOOT_METHOD_FILE)));
   37216        2907 :         PyModule_AddObject(m, "DNS_BOOT_METHOD_REGISTRY", PyLong_FromLong((uint16_t)(DNS_BOOT_METHOD_REGISTRY)));
   37217        2907 :         PyModule_AddObject(m, "DNS_BOOT_METHOD_DIRECTORY", PyLong_FromLong((uint16_t)(DNS_BOOT_METHOD_DIRECTORY)));
   37218        2907 :         PyModule_AddObject(m, "DNS_ALLOW_RFC_NAMES_ONLY", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ALLOW_RFC_NAMES_ONLY)));
   37219        2907 :         PyModule_AddObject(m, "DNS_ALLOW_NONRFC_NAMES", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ALLOW_NONRFC_NAMES)));
   37220        2907 :         PyModule_AddObject(m, "DNS_ALLOW_MULTIBYTE_NAMES", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ALLOW_MULTIBYTE_NAMES)));
   37221        2907 :         PyModule_AddObject(m, "DNS_ALLOW_ALL_NAMES", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ALLOW_ALL_NAMES)));
   37222        2907 :         PyModule_AddObject(m, "DNS_DP_AUTOCREATED", PyLong_FromUnsignedLongLong((uint32_t)(DNS_DP_AUTOCREATED)));
   37223        2907 :         PyModule_AddObject(m, "DNS_DP_LEGACY", PyLong_FromUnsignedLongLong((uint32_t)(DNS_DP_LEGACY)));
   37224        2907 :         PyModule_AddObject(m, "DNS_DP_DOMAIN_DEFAULT", PyLong_FromUnsignedLongLong((uint32_t)(DNS_DP_DOMAIN_DEFAULT)));
   37225        2907 :         PyModule_AddObject(m, "DNS_DP_FOREST_DEFAULT", PyLong_FromUnsignedLongLong((uint32_t)(DNS_DP_FOREST_DEFAULT)));
   37226        2907 :         PyModule_AddObject(m, "DNS_DP_ENLISTED", PyLong_FromUnsignedLongLong((uint32_t)(DNS_DP_ENLISTED)));
   37227        2907 :         PyModule_AddObject(m, "DNS_DP_DELETED", PyLong_FromUnsignedLongLong((uint32_t)(DNS_DP_DELETED)));
   37228        2907 :         PyModule_AddObject(m, "DNS_DP_OKAY", PyLong_FromUnsignedLongLong((uint32_t)(DNS_DP_OKAY)));
   37229        2907 :         PyModule_AddObject(m, "DNS_DP_STATE_REPL_INCOMING", PyLong_FromUnsignedLongLong((uint32_t)(DNS_DP_STATE_REPL_INCOMING)));
   37230        2907 :         PyModule_AddObject(m, "DNS_DP_STATE_REPL_OUTGOING", PyLong_FromUnsignedLongLong((uint32_t)(DNS_DP_STATE_REPL_OUTGOING)));
   37231        2907 :         PyModule_AddObject(m, "DNS_DP_STATE_UNKNOWN", PyLong_FromUnsignedLongLong((uint32_t)(DNS_DP_STATE_UNKNOWN)));
   37232        2907 :         PyModule_AddObject(m, "DNS_ZONE_SECSECURE_NO_SECURITY", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ZONE_SECSECURE_NO_SECURITY)));
   37233        2907 :         PyModule_AddObject(m, "DNS_ZONE_SECSECURE_NS_ONLY", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ZONE_SECSECURE_NS_ONLY)));
   37234        2907 :         PyModule_AddObject(m, "DNS_ZONE_SECSECURE_LIST_ONLY", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ZONE_SECSECURE_LIST_ONLY)));
   37235        2907 :         PyModule_AddObject(m, "DNS_ZONE_SECSECURE_NO_XFER", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ZONE_SECSECURE_NO_XFER)));
   37236        2907 :         PyModule_AddObject(m, "DNS_ZONE_NOTIFY_OFF", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ZONE_NOTIFY_OFF)));
   37237        2907 :         PyModule_AddObject(m, "DNS_ZONE_NOTIFY_ALL_SECONDARIES", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ZONE_NOTIFY_ALL_SECONDARIES)));
   37238        2907 :         PyModule_AddObject(m, "DNS_ZONE_NOTIFY_LIST_ONLY", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ZONE_NOTIFY_LIST_ONLY)));
   37239        2907 :         PyModule_AddObject(m, "DNS_ZONE_REQUEST_PRIMARY", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ZONE_REQUEST_PRIMARY)));
   37240        2907 :         PyModule_AddObject(m, "DNS_ZONE_REQUEST_SECONDARY", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ZONE_REQUEST_SECONDARY)));
   37241        2907 :         PyModule_AddObject(m, "DNS_ZONE_REQUEST_CACHE", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ZONE_REQUEST_CACHE)));
   37242        2907 :         PyModule_AddObject(m, "DNS_ZONE_REQUEST_AUTO", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ZONE_REQUEST_AUTO)));
   37243        2907 :         PyModule_AddObject(m, "DNS_ZONE_REQUEST_FORWARD", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ZONE_REQUEST_FORWARD)));
   37244        2907 :         PyModule_AddObject(m, "DNS_ZONE_REQUEST_REVERSE", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ZONE_REQUEST_REVERSE)));
   37245        2907 :         PyModule_AddObject(m, "DNS_ZONE_REQUEST_FORWARDER", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ZONE_REQUEST_FORWARDER)));
   37246        2907 :         PyModule_AddObject(m, "DNS_ZONE_REQUEST_STUB", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ZONE_REQUEST_STUB)));
   37247        2907 :         PyModule_AddObject(m, "DNS_ZONE_REQUEST_DS", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ZONE_REQUEST_DS)));
   37248        2907 :         PyModule_AddObject(m, "DNS_ZONE_REQUEST_NON_DS", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ZONE_REQUEST_NON_DS)));
   37249        2907 :         PyModule_AddObject(m, "DNS_ZONE_REQUEST_DOMAIN_DP", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ZONE_REQUEST_DOMAIN_DP)));
   37250        2907 :         PyModule_AddObject(m, "DNS_ZONE_REQUEST_FOREST_DP", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ZONE_REQUEST_FOREST_DP)));
   37251        2907 :         PyModule_AddObject(m, "DNS_ZONE_REQUEST_CUSTOM_DP", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ZONE_REQUEST_CUSTOM_DP)));
   37252        2907 :         PyModule_AddObject(m, "DNS_ZONE_REQUEST_LEGACY_DP", PyLong_FromUnsignedLongLong((uint32_t)(DNS_ZONE_REQUEST_LEGACY_DP)));
   37253        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_PAUSED", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_ZONE_PAUSED)));
   37254        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_SHUTDOWN", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_ZONE_SHUTDOWN)));
   37255        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_REVERSE", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_ZONE_REVERSE)));
   37256        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_AUTOCREATED", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_ZONE_AUTOCREATED)));
   37257        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_DSINTEGRATED", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_ZONE_DSINTEGRATED)));
   37258        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_AGING", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_ZONE_AGING)));
   37259        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_UPDATE_UNSECURE", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_ZONE_UPDATE_UNSECURE)));
   37260        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_UPDATE_SECURE", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_ZONE_UPDATE_SECURE)));
   37261        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_READONLY", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_ZONE_READONLY)));
   37262        2907 :         PyModule_AddObject(m, "DNS_RPC_AUTOCONFIG_INTERNAL_ROOTHINTS", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_AUTOCONFIG_INTERNAL_ROOTHINTS)));
   37263        2907 :         PyModule_AddObject(m, "DNS_RPC_AUTOCONFIG_INTERNAL_FORWARDERS", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_AUTOCONFIG_INTERNAL_FORWARDERS)));
   37264        2907 :         PyModule_AddObject(m, "DNS_RPC_AUTOCONFIG_INTERNAL_ZONES", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_AUTOCONFIG_INTERNAL_ZONES)));
   37265        2907 :         PyModule_AddObject(m, "DNS_RPC_AUTOCONFIG_INTERNAL_SELFPOINT", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_AUTOCONFIG_INTERNAL_SELFPOINT)));
   37266        2907 :         PyModule_AddObject(m, "DNS_RPC_AUTOCONFIG_INTERNAL_SELFPOINT_PREPEND", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_AUTOCONFIG_INTERNAL_SELFPOINT_PREPEND)));
   37267        2907 :         PyModule_AddObject(m, "DNS_RPC_AUTOCONFIG_INTERNAL_SELFPOINT_APPEND", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_AUTOCONFIG_INTERNAL_SELFPOINT_APPEND)));
   37268        2907 :         PyModule_AddObject(m, "DNS_RPC_AUTOCONFIG_INTERNAL_RETURN_ERROR", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_AUTOCONFIG_INTERNAL_RETURN_ERROR)));
   37269        2907 :         PyModule_AddObject(m, "DNS_RPC_AUTOCONFIG_ALL", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_AUTOCONFIG_ALL)));
   37270        2907 :         PyModule_AddObject(m, "DNS_EVENT_LOG_SUCCESS", PyLong_FromUnsignedLongLong((uint32_t)(DNS_EVENT_LOG_SUCCESS)));
   37271        2907 :         PyModule_AddObject(m, "DNS_EVENT_LOG_ERROR_TYPE", PyLong_FromUnsignedLongLong((uint32_t)(DNS_EVENT_LOG_ERROR_TYPE)));
   37272        2907 :         PyModule_AddObject(m, "DNS_EVENT_LOG_WARNING_TYPE", PyLong_FromUnsignedLongLong((uint32_t)(DNS_EVENT_LOG_WARNING_TYPE)));
   37273        2907 :         PyModule_AddObject(m, "DNS_EVENT_LOG_INFORMATION_TYPE", PyLong_FromUnsignedLongLong((uint32_t)(DNS_EVENT_LOG_INFORMATION_TYPE)));
   37274        2907 :         PyModule_AddObject(m, "DNS_RPC_VIEW_AUTHORITY_DATA", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_VIEW_AUTHORITY_DATA)));
   37275        2907 :         PyModule_AddObject(m, "DNS_RPC_VIEW_CACHE_DATA", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_VIEW_CACHE_DATA)));
   37276        2907 :         PyModule_AddObject(m, "DNS_RPC_VIEW_GLUE_DATA", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_VIEW_GLUE_DATA)));
   37277        2907 :         PyModule_AddObject(m, "DNS_RPC_VIEW_ROOT_HINT_DATA", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_VIEW_ROOT_HINT_DATA)));
   37278        2907 :         PyModule_AddObject(m, "DNS_RPC_VIEW_ADDITIONAL_DATA", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_VIEW_ADDITIONAL_DATA)));
   37279        2907 :         PyModule_AddObject(m, "DNS_RPC_VIEW_NO_CHILDREN", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_VIEW_NO_CHILDREN)));
   37280        2907 :         PyModule_AddObject(m, "DNS_RPC_VIEW_ONLY_CHILDREN", PyLong_FromUnsignedLongLong((uint32_t)(DNS_RPC_VIEW_ONLY_CHILDREN)));
   37281        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_NULL", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_NULL)));
   37282        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_DWORD", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_DWORD)));
   37283        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_LPSTR", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_LPSTR)));
   37284        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_LPWSTR", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_LPWSTR)));
   37285        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_IPARRAY", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_IPARRAY)));
   37286        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_BUFFER", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_BUFFER)));
   37287        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_SERVER_INFO_W2K", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_SERVER_INFO_W2K)));
   37288        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_STATS", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_STATS)));
   37289        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_FORWARDERS_W2K", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_FORWARDERS_W2K)));
   37290        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_ZONE_W2K", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_ZONE_W2K)));
   37291        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_ZONE_INFO_W2K", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_ZONE_INFO_W2K)));
   37292        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_ZONE_SECONDARIES_W2K", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_ZONE_SECONDARIES_W2K)));
   37293        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_ZONE_DATABASE_W2K", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_ZONE_DATABASE_W2K)));
   37294        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_ZONE_TYPE_RESET_W2K", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_ZONE_TYPE_RESET_W2K)));
   37295        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_ZONE_CREATE_W2K", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_ZONE_CREATE_W2K)));
   37296        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_NAME_AND_PARAM", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_NAME_AND_PARAM)));
   37297        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_ZONE_LIST_W2K", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_ZONE_LIST_W2K)));
   37298        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_ZONE_RENAME", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_ZONE_RENAME)));
   37299        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_ZONE_EXPORT", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_ZONE_EXPORT)));
   37300        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_SERVER_INFO_DOTNET", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_SERVER_INFO_DOTNET)));
   37301        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_FORWARDERS_DOTNET", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_FORWARDERS_DOTNET)));
   37302        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_ZONE", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_ZONE)));
   37303        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_ZONE_INFO_DOTNET", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_ZONE_INFO_DOTNET)));
   37304        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_ZONE_SECONDARIES_DOTNET", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_ZONE_SECONDARIES_DOTNET)));
   37305        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_ZONE_DATABASE", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_ZONE_DATABASE)));
   37306        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_ZONE_TYPE_RESET_DOTNET", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_ZONE_TYPE_RESET_DOTNET)));
   37307        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_ZONE_CREATE_DOTNET", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_ZONE_CREATE_DOTNET)));
   37308        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_ZONE_LIST", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_ZONE_LIST)));
   37309        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_DP_ENUM", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_DP_ENUM)));
   37310        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_DP_INFO", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_DP_INFO)));
   37311        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_DP_LIST", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_DP_LIST)));
   37312        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_ENLIST_DP", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_ENLIST_DP)));
   37313        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_ZONE_CHANGE_DP", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_ZONE_CHANGE_DP)));
   37314        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_ENUM_ZONES_FILTER", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_ENUM_ZONES_FILTER)));
   37315        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_ADDRARRAY", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_ADDRARRAY)));
   37316        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_SERVER_INFO", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_SERVER_INFO)));
   37317        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_ZONE_INFO", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_ZONE_INFO)));
   37318        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_FORWARDERS", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_FORWARDERS)));
   37319        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_ZONE_SECONDARIES", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_ZONE_SECONDARIES)));
   37320        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_ZONE_TYPE_RESET", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_ZONE_TYPE_RESET)));
   37321        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_ZONE_CREATE", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_ZONE_CREATE)));
   37322        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_IP_VALIDATE", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_IP_VALIDATE)));
   37323        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_AUTOCONFIGURE", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_AUTOCONFIGURE)));
   37324        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_UTF8_STRING_LIST", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_UTF8_STRING_LIST)));
   37325        2907 :         PyModule_AddObject(m, "DNSSRV_TYPEID_UNICODE_STRING_LIST", PyLong_FromUnsignedLongLong((uint32_t)(DNSSRV_TYPEID_UNICODE_STRING_LIST)));
   37326        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_BUFFER_Type);
   37327        2907 :         PyModule_AddObject(m, "DNS_RPC_BUFFER", (PyObject *)(void *)&DNS_RPC_BUFFER_Type);
   37328        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_UTF8_STRING_LIST_Type);
   37329        2907 :         PyModule_AddObject(m, "DNS_RPC_UTF8_STRING_LIST", (PyObject *)(void *)&DNS_RPC_UTF8_STRING_LIST_Type);
   37330        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_NAME_AND_PARAM_Type);
   37331        2907 :         PyModule_AddObject(m, "DNS_RPC_NAME_AND_PARAM", (PyObject *)(void *)&DNS_RPC_NAME_AND_PARAM_Type);
   37332        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_NAME_Type);
   37333        2907 :         PyModule_AddObject(m, "DNS_RPC_NAME", (PyObject *)(void *)&DNS_RPC_NAME_Type);
   37334        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_NODE_Type);
   37335        2907 :         PyModule_AddObject(m, "DNS_RPC_NODE", (PyObject *)(void *)&DNS_RPC_NODE_Type);
   37336        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_RECORD_SOA_Type);
   37337        2907 :         PyModule_AddObject(m, "DNS_RPC_RECORD_SOA", (PyObject *)(void *)&DNS_RPC_RECORD_SOA_Type);
   37338        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_RECORD_NAME_PREFERENCE_Type);
   37339        2907 :         PyModule_AddObject(m, "DNS_RPC_RECORD_NAME_PREFERENCE", (PyObject *)(void *)&DNS_RPC_RECORD_NAME_PREFERENCE_Type);
   37340        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_RECORD_STRING_Type);
   37341        2907 :         PyModule_AddObject(m, "DNS_RPC_RECORD_STRING", (PyObject *)(void *)&DNS_RPC_RECORD_STRING_Type);
   37342        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_RECORD_SRV_Type);
   37343        2907 :         PyModule_AddObject(m, "DNS_RPC_RECORD_SRV", (PyObject *)(void *)&DNS_RPC_RECORD_SRV_Type);
   37344        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_RECORD_DATA_Type);
   37345        2907 :         PyModule_AddObject(m, "DNS_RPC_RECORD_DATA", (PyObject *)(void *)&DNS_RPC_RECORD_DATA_Type);
   37346        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_RECORD_Type);
   37347        2907 :         PyModule_AddObject(m, "DNS_RPC_RECORD", (PyObject *)(void *)&DNS_RPC_RECORD_Type);
   37348        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_RECORD_BUF_Type);
   37349        2907 :         PyModule_AddObject(m, "DNS_RPC_RECORD_BUF", (PyObject *)(void *)&DNS_RPC_RECORD_BUF_Type);
   37350        2268 :         Py_INCREF((PyObject *)(void *)&IP4_ARRAY_Type);
   37351        2907 :         PyModule_AddObject(m, "IP4_ARRAY", (PyObject *)(void *)&IP4_ARRAY_Type);
   37352        2268 :         Py_INCREF((PyObject *)(void *)&DNS_ADDR_Type);
   37353        2907 :         PyModule_AddObject(m, "DNS_ADDR", (PyObject *)(void *)&DNS_ADDR_Type);
   37354        2268 :         Py_INCREF((PyObject *)(void *)&DNS_ADDR_ARRAY_Type);
   37355        2907 :         PyModule_AddObject(m, "DNS_ADDR_ARRAY", (PyObject *)(void *)&DNS_ADDR_ARRAY_Type);
   37356        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_IP_VALIDATE_Type);
   37357        2907 :         PyModule_AddObject(m, "DNS_RPC_IP_VALIDATE", (PyObject *)(void *)&DNS_RPC_IP_VALIDATE_Type);
   37358        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_SERVER_INFO_W2K_Type);
   37359        2907 :         PyModule_AddObject(m, "DNS_RPC_SERVER_INFO_W2K", (PyObject *)(void *)&DNS_RPC_SERVER_INFO_W2K_Type);
   37360        2268 :         Py_INCREF((PyObject *)(void *)&DNS_EXTENSION_Type);
   37361        2907 :         PyModule_AddObject(m, "DNS_EXTENSION", (PyObject *)(void *)&DNS_EXTENSION_Type);
   37362        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_SERVER_INFO_DOTNET_Type);
   37363        2907 :         PyModule_AddObject(m, "DNS_RPC_SERVER_INFO_DOTNET", (PyObject *)(void *)&DNS_RPC_SERVER_INFO_DOTNET_Type);
   37364        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_SERVER_INFO_LONGHORN_Type);
   37365        2907 :         PyModule_AddObject(m, "DNS_RPC_SERVER_INFO_LONGHORN", (PyObject *)(void *)&DNS_RPC_SERVER_INFO_LONGHORN_Type);
   37366        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_DP_REPLICA_Type);
   37367        2907 :         PyModule_AddObject(m, "DNS_RPC_DP_REPLICA", (PyObject *)(void *)&DNS_RPC_DP_REPLICA_Type);
   37368        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_DP_INFO_Type);
   37369        2907 :         PyModule_AddObject(m, "DNS_RPC_DP_INFO", (PyObject *)(void *)&DNS_RPC_DP_INFO_Type);
   37370        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_DP_ENUM_Type);
   37371        2907 :         PyModule_AddObject(m, "DNS_RPC_DP_ENUM", (PyObject *)(void *)&DNS_RPC_DP_ENUM_Type);
   37372        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_DP_LIST_Type);
   37373        2907 :         PyModule_AddObject(m, "DNS_RPC_DP_LIST", (PyObject *)(void *)&DNS_RPC_DP_LIST_Type);
   37374        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_ENLIST_DP_Type);
   37375        2907 :         PyModule_AddObject(m, "DNS_RPC_ENLIST_DP", (PyObject *)(void *)&DNS_RPC_ENLIST_DP_Type);
   37376        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_ZONE_CHANGE_DP_Type);
   37377        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_CHANGE_DP", (PyObject *)(void *)&DNS_RPC_ZONE_CHANGE_DP_Type);
   37378        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_ZONE_W2K_Type);
   37379        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_W2K", (PyObject *)(void *)&DNS_RPC_ZONE_W2K_Type);
   37380        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_ZONE_DOTNET_Type);
   37381        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_DOTNET", (PyObject *)(void *)&DNS_RPC_ZONE_DOTNET_Type);
   37382        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_ZONE_LIST_W2K_Type);
   37383        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_LIST_W2K", (PyObject *)(void *)&DNS_RPC_ZONE_LIST_W2K_Type);
   37384        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_ZONE_LIST_DOTNET_Type);
   37385        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_LIST_DOTNET", (PyObject *)(void *)&DNS_RPC_ZONE_LIST_DOTNET_Type);
   37386        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_ZONE_INFO_W2K_Type);
   37387        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_INFO_W2K", (PyObject *)(void *)&DNS_RPC_ZONE_INFO_W2K_Type);
   37388        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_ZONE_INFO_DOTNET_Type);
   37389        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_INFO_DOTNET", (PyObject *)(void *)&DNS_RPC_ZONE_INFO_DOTNET_Type);
   37390        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_ZONE_INFO_LONGHORN_Type);
   37391        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_INFO_LONGHORN", (PyObject *)(void *)&DNS_RPC_ZONE_INFO_LONGHORN_Type);
   37392        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_ZONE_SECONDARIES_W2K_Type);
   37393        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_SECONDARIES_W2K", (PyObject *)(void *)&DNS_RPC_ZONE_SECONDARIES_W2K_Type);
   37394        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_ZONE_SECONDARIES_DOTNET_Type);
   37395        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_SECONDARIES_DOTNET", (PyObject *)(void *)&DNS_RPC_ZONE_SECONDARIES_DOTNET_Type);
   37396        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_ZONE_SECONDARIES_LONGHORN_Type);
   37397        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_SECONDARIES_LONGHORN", (PyObject *)(void *)&DNS_RPC_ZONE_SECONDARIES_LONGHORN_Type);
   37398        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_ZONE_DATABASE_W2K_Type);
   37399        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_DATABASE_W2K", (PyObject *)(void *)&DNS_RPC_ZONE_DATABASE_W2K_Type);
   37400        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_ZONE_DATABASE_DOTNET_Type);
   37401        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_DATABASE_DOTNET", (PyObject *)(void *)&DNS_RPC_ZONE_DATABASE_DOTNET_Type);
   37402        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_ZONE_CREATE_INFO_W2K_Type);
   37403        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_CREATE_INFO_W2K", (PyObject *)(void *)&DNS_RPC_ZONE_CREATE_INFO_W2K_Type);
   37404        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_ZONE_CREATE_INFO_DOTNET_Type);
   37405        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_CREATE_INFO_DOTNET", (PyObject *)(void *)&DNS_RPC_ZONE_CREATE_INFO_DOTNET_Type);
   37406        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_ZONE_CREATE_INFO_LONGHORN_Type);
   37407        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_CREATE_INFO_LONGHORN", (PyObject *)(void *)&DNS_RPC_ZONE_CREATE_INFO_LONGHORN_Type);
   37408        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_ZONE_EXPORT_INFO_Type);
   37409        2907 :         PyModule_AddObject(m, "DNS_RPC_ZONE_EXPORT_INFO", (PyObject *)(void *)&DNS_RPC_ZONE_EXPORT_INFO_Type);
   37410        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_ENUM_ZONES_FILTER_Type);
   37411        2907 :         PyModule_AddObject(m, "DNS_RPC_ENUM_ZONES_FILTER", (PyObject *)(void *)&DNS_RPC_ENUM_ZONES_FILTER_Type);
   37412        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_FORWARDERS_W2K_Type);
   37413        2907 :         PyModule_AddObject(m, "DNS_RPC_FORWARDERS_W2K", (PyObject *)(void *)&DNS_RPC_FORWARDERS_W2K_Type);
   37414        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_FORWARDERS_DOTNET_Type);
   37415        2907 :         PyModule_AddObject(m, "DNS_RPC_FORWARDERS_DOTNET", (PyObject *)(void *)&DNS_RPC_FORWARDERS_DOTNET_Type);
   37416        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_FORWARDERS_LONGHORN_Type);
   37417        2907 :         PyModule_AddObject(m, "DNS_RPC_FORWARDERS_LONGHORN", (PyObject *)(void *)&DNS_RPC_FORWARDERS_LONGHORN_Type);
   37418        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_AUTOCONFIGURE_Type);
   37419        2907 :         PyModule_AddObject(m, "DNS_RPC_AUTOCONFIGURE", (PyObject *)(void *)&DNS_RPC_AUTOCONFIGURE_Type);
   37420        2268 :         Py_INCREF((PyObject *)(void *)&DNSSRV_STAT_HEADER_Type);
   37421        2907 :         PyModule_AddObject(m, "DNSSRV_STAT_HEADER", (PyObject *)(void *)&DNSSRV_STAT_HEADER_Type);
   37422        2268 :         Py_INCREF((PyObject *)(void *)&DNSSRV_STAT_Type);
   37423        2907 :         PyModule_AddObject(m, "DNSSRV_STAT", (PyObject *)(void *)&DNSSRV_STAT_Type);
   37424        2268 :         Py_INCREF((PyObject *)(void *)&DNSSRV_RPC_UNION_Type);
   37425        2907 :         PyModule_AddObject(m, "DNSSRV_RPC_UNION", (PyObject *)(void *)&DNSSRV_RPC_UNION_Type);
   37426        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_RECORDS_Type);
   37427        2907 :         PyModule_AddObject(m, "DNS_RPC_RECORDS", (PyObject *)(void *)&DNS_RPC_RECORDS_Type);
   37428        2268 :         Py_INCREF((PyObject *)(void *)&DNS_RPC_RECORDS_ARRAY_Type);
   37429        2907 :         PyModule_AddObject(m, "DNS_RPC_RECORDS_ARRAY", (PyObject *)(void *)&DNS_RPC_RECORDS_ARRAY_Type);
   37430        2268 :         Py_INCREF((PyObject *)(void *)&DnssrvOperation_Type);
   37431        2907 :         PyModule_AddObject(m, "DnssrvOperation", (PyObject *)(void *)&DnssrvOperation_Type);
   37432        2268 :         Py_INCREF((PyObject *)(void *)&DnssrvQuery_Type);
   37433        2907 :         PyModule_AddObject(m, "DnssrvQuery", (PyObject *)(void *)&DnssrvQuery_Type);
   37434        2268 :         Py_INCREF((PyObject *)(void *)&DnssrvComplexOperation_Type);
   37435        2907 :         PyModule_AddObject(m, "DnssrvComplexOperation", (PyObject *)(void *)&DnssrvComplexOperation_Type);
   37436        2268 :         Py_INCREF((PyObject *)(void *)&DnssrvEnumRecords_Type);
   37437        2907 :         PyModule_AddObject(m, "DnssrvEnumRecords", (PyObject *)(void *)&DnssrvEnumRecords_Type);
   37438        2268 :         Py_INCREF((PyObject *)(void *)&DnssrvUpdateRecord_Type);
   37439        2907 :         PyModule_AddObject(m, "DnssrvUpdateRecord", (PyObject *)(void *)&DnssrvUpdateRecord_Type);
   37440        2268 :         Py_INCREF((PyObject *)(void *)&DnssrvOperation2_Type);
   37441        2907 :         PyModule_AddObject(m, "DnssrvOperation2", (PyObject *)(void *)&DnssrvOperation2_Type);
   37442        2268 :         Py_INCREF((PyObject *)(void *)&DnssrvQuery2_Type);
   37443        2907 :         PyModule_AddObject(m, "DnssrvQuery2", (PyObject *)(void *)&DnssrvQuery2_Type);
   37444        2268 :         Py_INCREF((PyObject *)(void *)&DnssrvComplexOperation2_Type);
   37445        2907 :         PyModule_AddObject(m, "DnssrvComplexOperation2", (PyObject *)(void *)&DnssrvComplexOperation2_Type);
   37446        2268 :         Py_INCREF((PyObject *)(void *)&DnssrvEnumRecords2_Type);
   37447        2907 :         PyModule_AddObject(m, "DnssrvEnumRecords2", (PyObject *)(void *)&DnssrvEnumRecords2_Type);
   37448        2268 :         Py_INCREF((PyObject *)(void *)&DnssrvUpdateRecord2_Type);
   37449        2907 :         PyModule_AddObject(m, "DnssrvUpdateRecord2", (PyObject *)(void *)&DnssrvUpdateRecord2_Type);
   37450        2268 :         Py_INCREF((PyObject *)(void *)&dnsserver_InterfaceType);
   37451        2907 :         PyModule_AddObject(m, "dnsserver", (PyObject *)(void *)&dnsserver_InterfaceType);
   37452        2268 :         Py_INCREF((PyObject *)(void *)&dnsserver_SyntaxType);
   37453        2907 :         PyModule_AddObject(m, "dnsserver_abstract_syntax", (PyObject *)(void *)&dnsserver_SyntaxType);
   37454        2268 :         Py_INCREF((PyObject *)(void *)&dnsserver_SyntaxType);
   37455        2907 :         PyModule_AddObject(m, "abstract_syntax", (PyObject *)(void *)&dnsserver_SyntaxType);
   37456             : #ifdef PY_MOD_DNSSERVER_PATCH
   37457             :         PY_MOD_DNSSERVER_PATCH(m);
   37458             : #endif
   37459        2907 :         out:
   37460        2907 :         Py_XDECREF(dep_samba_dcerpc_misc);
   37461        2907 :         Py_XDECREF(dep_samba_dcerpc_dnsp);
   37462        2907 :         Py_XDECREF(dep_talloc);
   37463        2907 :         Py_XDECREF(dep_samba_dcerpc_base);
   37464        2838 :         return m;
   37465             : 
   37466             : }

Generated by: LCOV version 1.14