bin.gen_ndr/default/librpc/gen_ndr/py_nbt.c

   1
   2 /* Python wrapper functions auto-generated by pidl */
   3 #include <Python.h>
   4 #include "includes.h"
   5 #include <pytalloc.h>
   6 #include "librpc/rpc/pyrpc.h"
   7 #include "librpc/rpc/pyrpc_util.h"
   8 #include "bin/default/librpc/gen_ndr/ndr_nbt.h"
   9 #include "bin/default/librpc/gen_ndr/ndr_nbt_c.h"
  10
  11 #include "librpc/gen_ndr/misc.h"
  12 #include "librpc/gen_ndr/security.h"
  13 staticforward PyTypeObject nbt_name_Type;
  14 staticforward PyTypeObject nbt_name_question_Type;
  15 staticforward PyTypeObject nbt_rdata_address_Type;
  16 staticforward PyTypeObject nbt_rdata_netbios_Type;
  17 staticforward PyTypeObject nbt_statistics_Type;
  18 staticforward PyTypeObject nbt_status_name_Type;
  19 staticforward PyTypeObject nbt_rdata_status_Type;
  20 staticforward PyTypeObject nbt_rdata_data_Type;
  21 staticforward PyTypeObject nbt_res_rec_Type;
  22 staticforward PyTypeObject nbt_name_packet_Type;
  23 staticforward PyTypeObject smb_trans_body_Type;
  24 staticforward PyTypeObject dgram_smb_packet_Type;
  25 staticforward PyTypeObject dgram_message_Type;
  26 staticforward PyTypeObject nbt_dgram_packet_Type;
  27 staticforward PyTypeObject nbt_sockaddr_Type;
  28 staticforward PyTypeObject NETLOGON_SAM_LOGON_REQUEST_Type;
  29 staticforward PyTypeObject NETLOGON_LOGON_REQUEST_Type;
  30 staticforward PyTypeObject NETLOGON_SAM_LOGON_RESPONSE_NT40_Type;
  31 staticforward PyTypeObject NETLOGON_SAM_LOGON_RESPONSE_Type;
  32 staticforward PyTypeObject NETLOGON_SAM_LOGON_RESPONSE_EX_Type;
  33 staticforward PyTypeObject nbt_netlogon_query_for_pdc_Type;
  34 staticforward PyTypeObject nbt_netlogon_response_from_pdc_Type;
  35 staticforward PyTypeObject nbt_netlogon_response2_Type;
  36 staticforward PyTypeObject nbt_db_change_info_Type;
  37 staticforward PyTypeObject NETLOGON_DB_CHANGE_Type;
  38 staticforward PyTypeObject nbt_netlogon_packet_Type;
  39 staticforward PyTypeObject nbt_browse_host_announcement_Type;
  40 staticforward PyTypeObject nbt_browse_announcement_request_Type;
  41 staticforward PyTypeObject nbt_browse_election_request_Type;
  42 staticforward PyTypeObject nbt_browse_backup_list_request_Type;
  43 staticforward PyTypeObject nbt_browse_backup_list_response_Type;
  44 staticforward PyTypeObject nbt_browse_become_backup_Type;
  45 staticforward PyTypeObject nbt_browse_domain_announcement_Type;
  46 staticforward PyTypeObject nbt_browse_master_announcement_Type;
  47 staticforward PyTypeObject nbt_browse_reset_state_Type;
  48 staticforward PyTypeObject nbt_browse_local_master_announcement_Type;
  49 staticforward PyTypeObject nbt_browse_packet_Type;
  50 staticforward PyTypeObject nbt_InterfaceType;
  51
  52 void initnbt(void);static PyTypeObject *dom_sid_Type;
  53 static PyTypeObject *Object_Type;
  54 static PyTypeObject *GUID_Type;
  55 static PyTypeObject *ClientConnection_Type;
  56
  57 static PyObject *py_nbt_name_get_name(PyObject *obj, void *closure)
  58 {
  59         struct nbt_name *object = (struct nbt_name *)pytalloc_get_ptr(obj);
  60         PyObject *py_name;
  61         py_name = PyString_FromStringOrNULL(object->name);
  62         return py_name;
  63 }
  64
  65 static int py_nbt_name_set_name(PyObject *py_obj, PyObject *value, void *closure)
  66 {
  67         struct nbt_name *object = (struct nbt_name *)pytalloc_get_ptr(py_obj);
  68         object->name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
  69         return 0;
  70 }
  71
  72 static PyObject *py_nbt_name_get_scope(PyObject *obj, void *closure)
  73 {
  74         struct nbt_name *object = (struct nbt_name *)pytalloc_get_ptr(obj);
  75         PyObject *py_scope;
  76         py_scope = PyString_FromStringOrNULL(object->scope);
  77         return py_scope;
  78 }
  79
  80 static int py_nbt_name_set_scope(PyObject *py_obj, PyObject *value, void *closure)
  81 {
  82         struct nbt_name *object = (struct nbt_name *)pytalloc_get_ptr(py_obj);
  83         object->scope = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
  84         return 0;
  85 }
  86
  87 static PyObject *py_nbt_name_get_type(PyObject *obj, void *closure)
  88 {
  89         struct nbt_name *object = (struct nbt_name *)pytalloc_get_ptr(obj);
  90         PyObject *py_type;
  91         py_type = PyInt_FromLong(object->type);
  92         return py_type;
  93 }
  94
  95 static int py_nbt_name_set_type(PyObject *py_obj, PyObject *value, void *closure)
  96 {
  97         struct nbt_name *object = (struct nbt_name *)pytalloc_get_ptr(py_obj);
  98         if (PyLong_Check(value)) {
  99                 object->type = PyLong_AsLongLong(value);
 100         } else if (PyInt_Check(value)) {
 101                 object->type = PyInt_AsLong(value);
 102         } else {
 103                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 104                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 105                 return -1;
 106         }
 107         return 0;
 108 }
 109
 110 static PyGetSetDef py_nbt_name_getsetters[] = {
 111         { discard_const_p(char, "name"), py_nbt_name_get_name, py_nbt_name_set_name },
 112         { discard_const_p(char, "scope"), py_nbt_name_get_scope, py_nbt_name_set_scope },
 113         { discard_const_p(char, "type"), py_nbt_name_get_type, py_nbt_name_set_type },
 114         { NULL }
 115 };
 116
 117 static PyObject *py_nbt_name_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 118 {
 119         return pytalloc_new(struct nbt_name, type);
 120 }
 121
 122 static PyObject *py_nbt_name_ndr_pack(PyObject *py_obj)
 123 {
 124         struct nbt_name *object = (struct nbt_name *)pytalloc_get_ptr(py_obj);
 125         DATA_BLOB blob;
 126         enum ndr_err_code err;
 127         err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_nbt_name);
 128         if (err != NDR_ERR_SUCCESS) {
 129                 PyErr_SetNdrError(err);
 130                 return NULL;
 131         }
 132
 133         return PyString_FromStringAndSize((char *)blob.data, blob.length);
 134 }
 135
 136 static PyObject *py_nbt_name_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
 137 {
 138         struct nbt_name *object = (struct nbt_name *)pytalloc_get_ptr(py_obj);
 139         DATA_BLOB blob;
 140         int blob_length = 0;
 141         enum ndr_err_code err;
 142         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
 143         PyObject *allow_remaining_obj = NULL;
 144         bool allow_remaining = false;
 145
 146         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
 147                 discard_const_p(char *, kwnames),
 148                 &blob.data, &blob_length,
 149                 &allow_remaining_obj)) {
 150                 return NULL;
 151         }
 152         blob.length = blob_length;
 153
 154         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
 155                 allow_remaining = true;
 156         }
 157
 158         if (allow_remaining) {
 159                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_nbt_name);
 160         } else {
 161                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_nbt_name);
 162         }
 163         if (err != NDR_ERR_SUCCESS) {
 164                 PyErr_SetNdrError(err);
 165                 return NULL;
 166         }
 167
 168         Py_RETURN_NONE;
 169 }
 170
 171 static PyObject *py_nbt_name_ndr_print(PyObject *py_obj)
 172 {
 173         struct nbt_name *object = (struct nbt_name *)pytalloc_get_ptr(py_obj);
 174         PyObject *ret;
 175         char *retstr;
 176
 177         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_nbt_name, "nbt_name", object);
 178         ret = PyString_FromString(retstr);
 179         talloc_free(retstr);
 180
 181         return ret;
 182 }
 183
 184 static PyMethodDef py_nbt_name_methods[] = {
 185         { "__ndr_pack__", (PyCFunction)py_nbt_name_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
 186         { "__ndr_unpack__", (PyCFunction)py_nbt_name_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
 187         { "__ndr_print__", (PyCFunction)py_nbt_name_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
 188         { NULL, NULL, 0, NULL }
 189 };
 190
 191
 192 static PyTypeObject nbt_name_Type = {
 193         PyObject_HEAD_INIT(NULL) 0,
 194         .tp_name = "nbt.name",
 195         .tp_getset = py_nbt_name_getsetters,
 196         .tp_methods = py_nbt_name_methods,
 197         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 198         .tp_basicsize = sizeof(pytalloc_Object),
 199         .tp_new = py_nbt_name_new,
 200 };
 201
 202
 203 static PyObject *py_nbt_name_question_get_name(PyObject *obj, void *closure)
 204 {
 205         struct nbt_name_question *object = (struct nbt_name_question *)pytalloc_get_ptr(obj);
 206         PyObject *py_name;
 207         py_name = pytalloc_reference_ex(&nbt_name_Type, pytalloc_get_mem_ctx(obj), &object->name);
 208         return py_name;
 209 }
 210
 211 static int py_nbt_name_question_set_name(PyObject *py_obj, PyObject *value, void *closure)
 212 {
 213         struct nbt_name_question *object = (struct nbt_name_question *)pytalloc_get_ptr(py_obj);
 214         PY_CHECK_TYPE(&nbt_name_Type, value, return -1;);
 215         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
 216                 PyErr_NoMemory();
 217                 return -1;
 218         }
 219         object->name = *(struct nbt_name *)pytalloc_get_ptr(value);
 220         return 0;
 221 }
 222
 223 static PyObject *py_nbt_name_question_get_question_type(PyObject *obj, void *closure)
 224 {
 225         struct nbt_name_question *object = (struct nbt_name_question *)pytalloc_get_ptr(obj);
 226         PyObject *py_question_type;
 227         py_question_type = PyInt_FromLong(object->question_type);
 228         return py_question_type;
 229 }
 230
 231 static int py_nbt_name_question_set_question_type(PyObject *py_obj, PyObject *value, void *closure)
 232 {
 233         struct nbt_name_question *object = (struct nbt_name_question *)pytalloc_get_ptr(py_obj);
 234         if (PyLong_Check(value)) {
 235                 object->question_type = PyLong_AsLongLong(value);
 236         } else if (PyInt_Check(value)) {
 237                 object->question_type = PyInt_AsLong(value);
 238         } else {
 239                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 240                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 241                 return -1;
 242         }
 243         return 0;
 244 }
 245
 246 static PyObject *py_nbt_name_question_get_question_class(PyObject *obj, void *closure)
 247 {
 248         struct nbt_name_question *object = (struct nbt_name_question *)pytalloc_get_ptr(obj);
 249         PyObject *py_question_class;
 250         py_question_class = PyInt_FromLong(object->question_class);
 251         return py_question_class;
 252 }
 253
 254 static int py_nbt_name_question_set_question_class(PyObject *py_obj, PyObject *value, void *closure)
 255 {
 256         struct nbt_name_question *object = (struct nbt_name_question *)pytalloc_get_ptr(py_obj);
 257         if (PyLong_Check(value)) {
 258                 object->question_class = PyLong_AsLongLong(value);
 259         } else if (PyInt_Check(value)) {
 260                 object->question_class = PyInt_AsLong(value);
 261         } else {
 262                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 263                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 264                 return -1;
 265         }
 266         return 0;
 267 }
 268
 269 static PyGetSetDef py_nbt_name_question_getsetters[] = {
 270         { discard_const_p(char, "name"), py_nbt_name_question_get_name, py_nbt_name_question_set_name },
 271         { discard_const_p(char, "question_type"), py_nbt_name_question_get_question_type, py_nbt_name_question_set_question_type },
 272         { discard_const_p(char, "question_class"), py_nbt_name_question_get_question_class, py_nbt_name_question_set_question_class },
 273         { NULL }
 274 };
 275
 276 static PyObject *py_nbt_name_question_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 277 {
 278         return pytalloc_new(struct nbt_name_question, type);
 279 }
 280
 281
 282 static PyTypeObject nbt_name_question_Type = {
 283         PyObject_HEAD_INIT(NULL) 0,
 284         .tp_name = "nbt.name_question",
 285         .tp_getset = py_nbt_name_question_getsetters,
 286         .tp_methods = NULL,
 287         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 288         .tp_basicsize = sizeof(pytalloc_Object),
 289         .tp_new = py_nbt_name_question_new,
 290 };
 291
 292
 293 static PyObject *py_nbt_rdata_address_get_nb_flags(PyObject *obj, void *closure)
 294 {
 295         struct nbt_rdata_address *object = (struct nbt_rdata_address *)pytalloc_get_ptr(obj);
 296         PyObject *py_nb_flags;
 297         py_nb_flags = PyInt_FromLong(object->nb_flags);
 298         return py_nb_flags;
 299 }
 300
 301 static int py_nbt_rdata_address_set_nb_flags(PyObject *py_obj, PyObject *value, void *closure)
 302 {
 303         struct nbt_rdata_address *object = (struct nbt_rdata_address *)pytalloc_get_ptr(py_obj);
 304         if (PyLong_Check(value)) {
 305                 object->nb_flags = PyLong_AsLongLong(value);
 306         } else if (PyInt_Check(value)) {
 307                 object->nb_flags = PyInt_AsLong(value);
 308         } else {
 309                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 310                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 311                 return -1;
 312         }
 313         return 0;
 314 }
 315
 316 static PyObject *py_nbt_rdata_address_get_ipaddr(PyObject *obj, void *closure)
 317 {
 318         struct nbt_rdata_address *object = (struct nbt_rdata_address *)pytalloc_get_ptr(obj);
 319         PyObject *py_ipaddr;
 320         py_ipaddr = PyString_FromStringOrNULL(object->ipaddr);
 321         return py_ipaddr;
 322 }
 323
 324 static int py_nbt_rdata_address_set_ipaddr(PyObject *py_obj, PyObject *value, void *closure)
 325 {
 326         struct nbt_rdata_address *object = (struct nbt_rdata_address *)pytalloc_get_ptr(py_obj);
 327         object->ipaddr = PyString_AS_STRING(value);
 328         return 0;
 329 }
 330
 331 static PyGetSetDef py_nbt_rdata_address_getsetters[] = {
 332         { discard_const_p(char, "nb_flags"), py_nbt_rdata_address_get_nb_flags, py_nbt_rdata_address_set_nb_flags },
 333         { discard_const_p(char, "ipaddr"), py_nbt_rdata_address_get_ipaddr, py_nbt_rdata_address_set_ipaddr },
 334         { NULL }
 335 };
 336
 337 static PyObject *py_nbt_rdata_address_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 338 {
 339         return pytalloc_new(struct nbt_rdata_address, type);
 340 }
 341
 342
 343 static PyTypeObject nbt_rdata_address_Type = {
 344         PyObject_HEAD_INIT(NULL) 0,
 345         .tp_name = "nbt.rdata_address",
 346         .tp_getset = py_nbt_rdata_address_getsetters,
 347         .tp_methods = NULL,
 348         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 349         .tp_basicsize = sizeof(pytalloc_Object),
 350         .tp_new = py_nbt_rdata_address_new,
 351 };
 352
 353
 354 static PyObject *py_nbt_rdata_netbios_get_length(PyObject *obj, void *closure)
 355 {
 356         struct nbt_rdata_netbios *object = (struct nbt_rdata_netbios *)pytalloc_get_ptr(obj);
 357         PyObject *py_length;
 358         py_length = PyInt_FromLong(object->length);
 359         return py_length;
 360 }
 361
 362 static int py_nbt_rdata_netbios_set_length(PyObject *py_obj, PyObject *value, void *closure)
 363 {
 364         struct nbt_rdata_netbios *object = (struct nbt_rdata_netbios *)pytalloc_get_ptr(py_obj);
 365         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 366         object->length = PyInt_AsLong(value);
 367         return 0;
 368 }
 369
 370 static PyObject *py_nbt_rdata_netbios_get_addresses(PyObject *obj, void *closure)
 371 {
 372         struct nbt_rdata_netbios *object = (struct nbt_rdata_netbios *)pytalloc_get_ptr(obj);
 373         PyObject *py_addresses;
 374         py_addresses = PyList_New(object->length / 6);
 375         if (py_addresses == NULL) {
 376                 return NULL;
 377         }
 378         {
 379                 int addresses_cntr_0;
 380                 for (addresses_cntr_0 = 0; addresses_cntr_0 < object->length / 6; addresses_cntr_0++) {
 381                         PyObject *py_addresses_0;
 382                         py_addresses_0 = pytalloc_reference_ex(&nbt_rdata_address_Type, object->addresses, &object->addresses[addresses_cntr_0]);
 383                         PyList_SetItem(py_addresses, addresses_cntr_0, py_addresses_0);
 384                 }
 385         }
 386         return py_addresses;
 387 }
 388
 389 static int py_nbt_rdata_netbios_set_addresses(PyObject *py_obj, PyObject *value, void *closure)
 390 {
 391         struct nbt_rdata_netbios *object = (struct nbt_rdata_netbios *)pytalloc_get_ptr(py_obj);
 392         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
 393         {
 394                 int addresses_cntr_0;
 395                 object->addresses = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->addresses, PyList_GET_SIZE(value));
 396                 if (!object->addresses) { return -1;; }
 397                 talloc_set_name_const(object->addresses, "ARRAY: object->addresses");
 398                 for (addresses_cntr_0 = 0; addresses_cntr_0 < PyList_GET_SIZE(value); addresses_cntr_0++) {
 399                         PY_CHECK_TYPE(&nbt_rdata_address_Type, PyList_GET_ITEM(value, addresses_cntr_0), return -1;);
 400                         if (talloc_reference(object->addresses, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, addresses_cntr_0))) == NULL) {
 401                                 PyErr_NoMemory();
 402                                 return -1;
 403                         }
 404                         object->addresses[addresses_cntr_0] = *(struct nbt_rdata_address *)pytalloc_get_ptr(PyList_GET_ITEM(value, addresses_cntr_0));
 405                 }
 406         }
 407         return 0;
 408 }
 409
 410 static PyGetSetDef py_nbt_rdata_netbios_getsetters[] = {
 411         { discard_const_p(char, "length"), py_nbt_rdata_netbios_get_length, py_nbt_rdata_netbios_set_length },
 412         { discard_const_p(char, "addresses"), py_nbt_rdata_netbios_get_addresses, py_nbt_rdata_netbios_set_addresses },
 413         { NULL }
 414 };
 415
 416 static PyObject *py_nbt_rdata_netbios_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 417 {
 418         return pytalloc_new(struct nbt_rdata_netbios, type);
 419 }
 420
 421
 422 static PyTypeObject nbt_rdata_netbios_Type = {
 423         PyObject_HEAD_INIT(NULL) 0,
 424         .tp_name = "nbt.rdata_netbios",
 425         .tp_getset = py_nbt_rdata_netbios_getsetters,
 426         .tp_methods = NULL,
 427         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 428         .tp_basicsize = sizeof(pytalloc_Object),
 429         .tp_new = py_nbt_rdata_netbios_new,
 430 };
 431
 432
 433 static PyObject *py_nbt_statistics_get_unit_id(PyObject *obj, void *closure)
 434 {
 435         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(obj);
 436         PyObject *py_unit_id;
 437         py_unit_id = PyList_New(6);
 438         if (py_unit_id == NULL) {
 439                 return NULL;
 440         }
 441         {
 442                 int unit_id_cntr_0;
 443                 for (unit_id_cntr_0 = 0; unit_id_cntr_0 < 6; unit_id_cntr_0++) {
 444                         PyObject *py_unit_id_0;
 445                         py_unit_id_0 = PyInt_FromLong(object->unit_id[unit_id_cntr_0]);
 446                         PyList_SetItem(py_unit_id, unit_id_cntr_0, py_unit_id_0);
 447                 }
 448         }
 449         return py_unit_id;
 450 }
 451
 452 static int py_nbt_statistics_set_unit_id(PyObject *py_obj, PyObject *value, void *closure)
 453 {
 454         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(py_obj);
 455         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
 456         {
 457                 int unit_id_cntr_0;
 458                 for (unit_id_cntr_0 = 0; unit_id_cntr_0 < PyList_GET_SIZE(value); unit_id_cntr_0++) {
 459                         PY_CHECK_TYPE(&PyInt_Type, PyList_GET_ITEM(value, unit_id_cntr_0), return -1;);
 460                         object->unit_id[unit_id_cntr_0] = PyInt_AsLong(PyList_GET_ITEM(value, unit_id_cntr_0));
 461                 }
 462         }
 463         return 0;
 464 }
 465
 466 static PyObject *py_nbt_statistics_get_jumpers(PyObject *obj, void *closure)
 467 {
 468         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(obj);
 469         PyObject *py_jumpers;
 470         py_jumpers = PyInt_FromLong(object->jumpers);
 471         return py_jumpers;
 472 }
 473
 474 static int py_nbt_statistics_set_jumpers(PyObject *py_obj, PyObject *value, void *closure)
 475 {
 476         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(py_obj);
 477         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 478         object->jumpers = PyInt_AsLong(value);
 479         return 0;
 480 }
 481
 482 static PyObject *py_nbt_statistics_get_test_result(PyObject *obj, void *closure)
 483 {
 484         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(obj);
 485         PyObject *py_test_result;
 486         py_test_result = PyInt_FromLong(object->test_result);
 487         return py_test_result;
 488 }
 489
 490 static int py_nbt_statistics_set_test_result(PyObject *py_obj, PyObject *value, void *closure)
 491 {
 492         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(py_obj);
 493         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 494         object->test_result = PyInt_AsLong(value);
 495         return 0;
 496 }
 497
 498 static PyObject *py_nbt_statistics_get_version_number(PyObject *obj, void *closure)
 499 {
 500         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(obj);
 501         PyObject *py_version_number;
 502         py_version_number = PyInt_FromLong(object->version_number);
 503         return py_version_number;
 504 }
 505
 506 static int py_nbt_statistics_set_version_number(PyObject *py_obj, PyObject *value, void *closure)
 507 {
 508         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(py_obj);
 509         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 510         object->version_number = PyInt_AsLong(value);
 511         return 0;
 512 }
 513
 514 static PyObject *py_nbt_statistics_get_period_of_statistics(PyObject *obj, void *closure)
 515 {
 516         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(obj);
 517         PyObject *py_period_of_statistics;
 518         py_period_of_statistics = PyInt_FromLong(object->period_of_statistics);
 519         return py_period_of_statistics;
 520 }
 521
 522 static int py_nbt_statistics_set_period_of_statistics(PyObject *py_obj, PyObject *value, void *closure)
 523 {
 524         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(py_obj);
 525         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 526         object->period_of_statistics = PyInt_AsLong(value);
 527         return 0;
 528 }
 529
 530 static PyObject *py_nbt_statistics_get_number_of_crcs(PyObject *obj, void *closure)
 531 {
 532         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(obj);
 533         PyObject *py_number_of_crcs;
 534         py_number_of_crcs = PyInt_FromLong(object->number_of_crcs);
 535         return py_number_of_crcs;
 536 }
 537
 538 static int py_nbt_statistics_set_number_of_crcs(PyObject *py_obj, PyObject *value, void *closure)
 539 {
 540         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(py_obj);
 541         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 542         object->number_of_crcs = PyInt_AsLong(value);
 543         return 0;
 544 }
 545
 546 static PyObject *py_nbt_statistics_get_number_alignment_errors(PyObject *obj, void *closure)
 547 {
 548         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(obj);
 549         PyObject *py_number_alignment_errors;
 550         py_number_alignment_errors = PyInt_FromLong(object->number_alignment_errors);
 551         return py_number_alignment_errors;
 552 }
 553
 554 static int py_nbt_statistics_set_number_alignment_errors(PyObject *py_obj, PyObject *value, void *closure)
 555 {
 556         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(py_obj);
 557         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 558         object->number_alignment_errors = PyInt_AsLong(value);
 559         return 0;
 560 }
 561
 562 static PyObject *py_nbt_statistics_get_number_of_collisions(PyObject *obj, void *closure)
 563 {
 564         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(obj);
 565         PyObject *py_number_of_collisions;
 566         py_number_of_collisions = PyInt_FromLong(object->number_of_collisions);
 567         return py_number_of_collisions;
 568 }
 569
 570 static int py_nbt_statistics_set_number_of_collisions(PyObject *py_obj, PyObject *value, void *closure)
 571 {
 572         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(py_obj);
 573         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 574         object->number_of_collisions = PyInt_AsLong(value);
 575         return 0;
 576 }
 577
 578 static PyObject *py_nbt_statistics_get_number_send_aborts(PyObject *obj, void *closure)
 579 {
 580         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(obj);
 581         PyObject *py_number_send_aborts;
 582         py_number_send_aborts = PyInt_FromLong(object->number_send_aborts);
 583         return py_number_send_aborts;
 584 }
 585
 586 static int py_nbt_statistics_set_number_send_aborts(PyObject *py_obj, PyObject *value, void *closure)
 587 {
 588         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(py_obj);
 589         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 590         object->number_send_aborts = PyInt_AsLong(value);
 591         return 0;
 592 }
 593
 594 static PyObject *py_nbt_statistics_get_number_good_sends(PyObject *obj, void *closure)
 595 {
 596         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(obj);
 597         PyObject *py_number_good_sends;
 598         py_number_good_sends = PyInt_FromLong(object->number_good_sends);
 599         return py_number_good_sends;
 600 }
 601
 602 static int py_nbt_statistics_set_number_good_sends(PyObject *py_obj, PyObject *value, void *closure)
 603 {
 604         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(py_obj);
 605         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 606         object->number_good_sends = PyInt_AsLong(value);
 607         return 0;
 608 }
 609
 610 static PyObject *py_nbt_statistics_get_number_good_receives(PyObject *obj, void *closure)
 611 {
 612         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(obj);
 613         PyObject *py_number_good_receives;
 614         py_number_good_receives = PyInt_FromLong(object->number_good_receives);
 615         return py_number_good_receives;
 616 }
 617
 618 static int py_nbt_statistics_set_number_good_receives(PyObject *py_obj, PyObject *value, void *closure)
 619 {
 620         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(py_obj);
 621         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 622         object->number_good_receives = PyInt_AsLong(value);
 623         return 0;
 624 }
 625
 626 static PyObject *py_nbt_statistics_get_number_retransmits(PyObject *obj, void *closure)
 627 {
 628         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(obj);
 629         PyObject *py_number_retransmits;
 630         py_number_retransmits = PyInt_FromLong(object->number_retransmits);
 631         return py_number_retransmits;
 632 }
 633
 634 static int py_nbt_statistics_set_number_retransmits(PyObject *py_obj, PyObject *value, void *closure)
 635 {
 636         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(py_obj);
 637         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 638         object->number_retransmits = PyInt_AsLong(value);
 639         return 0;
 640 }
 641
 642 static PyObject *py_nbt_statistics_get_number_no_resource_conditions(PyObject *obj, void *closure)
 643 {
 644         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(obj);
 645         PyObject *py_number_no_resource_conditions;
 646         py_number_no_resource_conditions = PyInt_FromLong(object->number_no_resource_conditions);
 647         return py_number_no_resource_conditions;
 648 }
 649
 650 static int py_nbt_statistics_set_number_no_resource_conditions(PyObject *py_obj, PyObject *value, void *closure)
 651 {
 652         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(py_obj);
 653         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 654         object->number_no_resource_conditions = PyInt_AsLong(value);
 655         return 0;
 656 }
 657
 658 static PyObject *py_nbt_statistics_get_number_free_command_blocks(PyObject *obj, void *closure)
 659 {
 660         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(obj);
 661         PyObject *py_number_free_command_blocks;
 662         py_number_free_command_blocks = PyInt_FromLong(object->number_free_command_blocks);
 663         return py_number_free_command_blocks;
 664 }
 665
 666 static int py_nbt_statistics_set_number_free_command_blocks(PyObject *py_obj, PyObject *value, void *closure)
 667 {
 668         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(py_obj);
 669         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 670         object->number_free_command_blocks = PyInt_AsLong(value);
 671         return 0;
 672 }
 673
 674 static PyObject *py_nbt_statistics_get_total_number_command_blocks(PyObject *obj, void *closure)
 675 {
 676         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(obj);
 677         PyObject *py_total_number_command_blocks;
 678         py_total_number_command_blocks = PyInt_FromLong(object->total_number_command_blocks);
 679         return py_total_number_command_blocks;
 680 }
 681
 682 static int py_nbt_statistics_set_total_number_command_blocks(PyObject *py_obj, PyObject *value, void *closure)
 683 {
 684         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(py_obj);
 685         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 686         object->total_number_command_blocks = PyInt_AsLong(value);
 687         return 0;
 688 }
 689
 690 static PyObject *py_nbt_statistics_get_max_total_number_command_blocks(PyObject *obj, void *closure)
 691 {
 692         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(obj);
 693         PyObject *py_max_total_number_command_blocks;
 694         py_max_total_number_command_blocks = PyInt_FromLong(object->max_total_number_command_blocks);
 695         return py_max_total_number_command_blocks;
 696 }
 697
 698 static int py_nbt_statistics_set_max_total_number_command_blocks(PyObject *py_obj, PyObject *value, void *closure)
 699 {
 700         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(py_obj);
 701         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 702         object->max_total_number_command_blocks = PyInt_AsLong(value);
 703         return 0;
 704 }
 705
 706 static PyObject *py_nbt_statistics_get_number_pending_sessions(PyObject *obj, void *closure)
 707 {
 708         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(obj);
 709         PyObject *py_number_pending_sessions;
 710         py_number_pending_sessions = PyInt_FromLong(object->number_pending_sessions);
 711         return py_number_pending_sessions;
 712 }
 713
 714 static int py_nbt_statistics_set_number_pending_sessions(PyObject *py_obj, PyObject *value, void *closure)
 715 {
 716         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(py_obj);
 717         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 718         object->number_pending_sessions = PyInt_AsLong(value);
 719         return 0;
 720 }
 721
 722 static PyObject *py_nbt_statistics_get_max_number_pending_sessions(PyObject *obj, void *closure)
 723 {
 724         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(obj);
 725         PyObject *py_max_number_pending_sessions;
 726         py_max_number_pending_sessions = PyInt_FromLong(object->max_number_pending_sessions);
 727         return py_max_number_pending_sessions;
 728 }
 729
 730 static int py_nbt_statistics_set_max_number_pending_sessions(PyObject *py_obj, PyObject *value, void *closure)
 731 {
 732         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(py_obj);
 733         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 734         object->max_number_pending_sessions = PyInt_AsLong(value);
 735         return 0;
 736 }
 737
 738 static PyObject *py_nbt_statistics_get_max_total_sessions_possible(PyObject *obj, void *closure)
 739 {
 740         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(obj);
 741         PyObject *py_max_total_sessions_possible;
 742         py_max_total_sessions_possible = PyInt_FromLong(object->max_total_sessions_possible);
 743         return py_max_total_sessions_possible;
 744 }
 745
 746 static int py_nbt_statistics_set_max_total_sessions_possible(PyObject *py_obj, PyObject *value, void *closure)
 747 {
 748         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(py_obj);
 749         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 750         object->max_total_sessions_possible = PyInt_AsLong(value);
 751         return 0;
 752 }
 753
 754 static PyObject *py_nbt_statistics_get_session_data_packet_size(PyObject *obj, void *closure)
 755 {
 756         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(obj);
 757         PyObject *py_session_data_packet_size;
 758         py_session_data_packet_size = PyInt_FromLong(object->session_data_packet_size);
 759         return py_session_data_packet_size;
 760 }
 761
 762 static int py_nbt_statistics_set_session_data_packet_size(PyObject *py_obj, PyObject *value, void *closure)
 763 {
 764         struct nbt_statistics *object = (struct nbt_statistics *)pytalloc_get_ptr(py_obj);
 765         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 766         object->session_data_packet_size = PyInt_AsLong(value);
 767         return 0;
 768 }
 769
 770 static PyGetSetDef py_nbt_statistics_getsetters[] = {
 771         { discard_const_p(char, "unit_id"), py_nbt_statistics_get_unit_id, py_nbt_statistics_set_unit_id },
 772         { discard_const_p(char, "jumpers"), py_nbt_statistics_get_jumpers, py_nbt_statistics_set_jumpers },
 773         { discard_const_p(char, "test_result"), py_nbt_statistics_get_test_result, py_nbt_statistics_set_test_result },
 774         { discard_const_p(char, "version_number"), py_nbt_statistics_get_version_number, py_nbt_statistics_set_version_number },
 775         { discard_const_p(char, "period_of_statistics"), py_nbt_statistics_get_period_of_statistics, py_nbt_statistics_set_period_of_statistics },
 776         { discard_const_p(char, "number_of_crcs"), py_nbt_statistics_get_number_of_crcs, py_nbt_statistics_set_number_of_crcs },
 777         { discard_const_p(char, "number_alignment_errors"), py_nbt_statistics_get_number_alignment_errors, py_nbt_statistics_set_number_alignment_errors },
 778         { discard_const_p(char, "number_of_collisions"), py_nbt_statistics_get_number_of_collisions, py_nbt_statistics_set_number_of_collisions },
 779         { discard_const_p(char, "number_send_aborts"), py_nbt_statistics_get_number_send_aborts, py_nbt_statistics_set_number_send_aborts },
 780         { discard_const_p(char, "number_good_sends"), py_nbt_statistics_get_number_good_sends, py_nbt_statistics_set_number_good_sends },
 781         { discard_const_p(char, "number_good_receives"), py_nbt_statistics_get_number_good_receives, py_nbt_statistics_set_number_good_receives },
 782         { discard_const_p(char, "number_retransmits"), py_nbt_statistics_get_number_retransmits, py_nbt_statistics_set_number_retransmits },
 783         { discard_const_p(char, "number_no_resource_conditions"), py_nbt_statistics_get_number_no_resource_conditions, py_nbt_statistics_set_number_no_resource_conditions },
 784         { discard_const_p(char, "number_free_command_blocks"), py_nbt_statistics_get_number_free_command_blocks, py_nbt_statistics_set_number_free_command_blocks },
 785         { discard_const_p(char, "total_number_command_blocks"), py_nbt_statistics_get_total_number_command_blocks, py_nbt_statistics_set_total_number_command_blocks },
 786         { discard_const_p(char, "max_total_number_command_blocks"), py_nbt_statistics_get_max_total_number_command_blocks, py_nbt_statistics_set_max_total_number_command_blocks },
 787         { discard_const_p(char, "number_pending_sessions"), py_nbt_statistics_get_number_pending_sessions, py_nbt_statistics_set_number_pending_sessions },
 788         { discard_const_p(char, "max_number_pending_sessions"), py_nbt_statistics_get_max_number_pending_sessions, py_nbt_statistics_set_max_number_pending_sessions },
 789         { discard_const_p(char, "max_total_sessions_possible"), py_nbt_statistics_get_max_total_sessions_possible, py_nbt_statistics_set_max_total_sessions_possible },
 790         { discard_const_p(char, "session_data_packet_size"), py_nbt_statistics_get_session_data_packet_size, py_nbt_statistics_set_session_data_packet_size },
 791         { NULL }
 792 };
 793
 794 static PyObject *py_nbt_statistics_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 795 {
 796         return pytalloc_new(struct nbt_statistics, type);
 797 }
 798
 799
 800 static PyTypeObject nbt_statistics_Type = {
 801         PyObject_HEAD_INIT(NULL) 0,
 802         .tp_name = "nbt.statistics",
 803         .tp_getset = py_nbt_statistics_getsetters,
 804         .tp_methods = NULL,
 805         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 806         .tp_basicsize = sizeof(pytalloc_Object),
 807         .tp_new = py_nbt_statistics_new,
 808 };
 809
 810
 811 static PyObject *py_nbt_status_name_get_name(PyObject *obj, void *closure)
 812 {
 813         struct nbt_status_name *object = (struct nbt_status_name *)pytalloc_get_ptr(obj);
 814         PyObject *py_name;
 815         if (object->name == NULL) {
 816                 py_name = Py_None;
 817                 Py_INCREF(py_name);
 818         } else {
 819                 py_name = PyUnicode_Decode(object->name, strlen(object->name), "utf-8", "ignore");
 820         }
 821         return py_name;
 822 }
 823
 824 static int py_nbt_status_name_set_name(PyObject *py_obj, PyObject *value, void *closure)
 825 {
 826         struct nbt_status_name *object = (struct nbt_status_name *)pytalloc_get_ptr(py_obj);
 827         if (PyUnicode_Check(value)) {
 828                 object->name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
 829         } else if (PyString_Check(value)) {
 830                 object->name = PyString_AS_STRING(value);
 831         } else {
 832                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
 833                 return -1;
 834         }
 835         return 0;
 836 }
 837
 838 static PyObject *py_nbt_status_name_get_type(PyObject *obj, void *closure)
 839 {
 840         struct nbt_status_name *object = (struct nbt_status_name *)pytalloc_get_ptr(obj);
 841         PyObject *py_type;
 842         py_type = PyInt_FromLong(object->type);
 843         return py_type;
 844 }
 845
 846 static int py_nbt_status_name_set_type(PyObject *py_obj, PyObject *value, void *closure)
 847 {
 848         struct nbt_status_name *object = (struct nbt_status_name *)pytalloc_get_ptr(py_obj);
 849         if (PyLong_Check(value)) {
 850                 object->type = PyLong_AsLongLong(value);
 851         } else if (PyInt_Check(value)) {
 852                 object->type = PyInt_AsLong(value);
 853         } else {
 854                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 855                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 856                 return -1;
 857         }
 858         return 0;
 859 }
 860
 861 static PyObject *py_nbt_status_name_get_nb_flags(PyObject *obj, void *closure)
 862 {
 863         struct nbt_status_name *object = (struct nbt_status_name *)pytalloc_get_ptr(obj);
 864         PyObject *py_nb_flags;
 865         py_nb_flags = PyInt_FromLong(object->nb_flags);
 866         return py_nb_flags;
 867 }
 868
 869 static int py_nbt_status_name_set_nb_flags(PyObject *py_obj, PyObject *value, void *closure)
 870 {
 871         struct nbt_status_name *object = (struct nbt_status_name *)pytalloc_get_ptr(py_obj);
 872         if (PyLong_Check(value)) {
 873                 object->nb_flags = PyLong_AsLongLong(value);
 874         } else if (PyInt_Check(value)) {
 875                 object->nb_flags = PyInt_AsLong(value);
 876         } else {
 877                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 878                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 879                 return -1;
 880         }
 881         return 0;
 882 }
 883
 884 static PyGetSetDef py_nbt_status_name_getsetters[] = {
 885         { discard_const_p(char, "name"), py_nbt_status_name_get_name, py_nbt_status_name_set_name },
 886         { discard_const_p(char, "type"), py_nbt_status_name_get_type, py_nbt_status_name_set_type },
 887         { discard_const_p(char, "nb_flags"), py_nbt_status_name_get_nb_flags, py_nbt_status_name_set_nb_flags },
 888         { NULL }
 889 };
 890
 891 static PyObject *py_nbt_status_name_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 892 {
 893         return pytalloc_new(struct nbt_status_name, type);
 894 }
 895
 896
 897 static PyTypeObject nbt_status_name_Type = {
 898         PyObject_HEAD_INIT(NULL) 0,
 899         .tp_name = "nbt.status_name",
 900         .tp_getset = py_nbt_status_name_getsetters,
 901         .tp_methods = NULL,
 902         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 903         .tp_basicsize = sizeof(pytalloc_Object),
 904         .tp_new = py_nbt_status_name_new,
 905 };
 906
 907
 908 static PyObject *py_nbt_rdata_status_get_length(PyObject *obj, void *closure)
 909 {
 910         struct nbt_rdata_status *object = (struct nbt_rdata_status *)pytalloc_get_ptr(obj);
 911         PyObject *py_length;
 912         py_length = PyInt_FromLong(object->length);
 913         return py_length;
 914 }
 915
 916 static int py_nbt_rdata_status_set_length(PyObject *py_obj, PyObject *value, void *closure)
 917 {
 918         struct nbt_rdata_status *object = (struct nbt_rdata_status *)pytalloc_get_ptr(py_obj);
 919         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 920         object->length = PyInt_AsLong(value);
 921         return 0;
 922 }
 923
 924 static PyObject *py_nbt_rdata_status_get_num_names(PyObject *obj, void *closure)
 925 {
 926         struct nbt_rdata_status *object = (struct nbt_rdata_status *)pytalloc_get_ptr(obj);
 927         PyObject *py_num_names;
 928         py_num_names = PyInt_FromLong(object->num_names);
 929         return py_num_names;
 930 }
 931
 932 static int py_nbt_rdata_status_set_num_names(PyObject *py_obj, PyObject *value, void *closure)
 933 {
 934         struct nbt_rdata_status *object = (struct nbt_rdata_status *)pytalloc_get_ptr(py_obj);
 935         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 936         object->num_names = PyInt_AsLong(value);
 937         return 0;
 938 }
 939
 940 static PyObject *py_nbt_rdata_status_get_names(PyObject *obj, void *closure)
 941 {
 942         struct nbt_rdata_status *object = (struct nbt_rdata_status *)pytalloc_get_ptr(obj);
 943         PyObject *py_names;
 944         py_names = PyList_New(object->num_names);
 945         if (py_names == NULL) {
 946                 return NULL;
 947         }
 948         {
 949                 int names_cntr_0;
 950                 for (names_cntr_0 = 0; names_cntr_0 < object->num_names; names_cntr_0++) {
 951                         PyObject *py_names_0;
 952                         py_names_0 = pytalloc_reference_ex(&nbt_status_name_Type, object->names, &object->names[names_cntr_0]);
 953                         PyList_SetItem(py_names, names_cntr_0, py_names_0);
 954                 }
 955         }
 956         return py_names;
 957 }
 958
 959 static int py_nbt_rdata_status_set_names(PyObject *py_obj, PyObject *value, void *closure)
 960 {
 961         struct nbt_rdata_status *object = (struct nbt_rdata_status *)pytalloc_get_ptr(py_obj);
 962         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
 963         {
 964                 int names_cntr_0;
 965                 object->names = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->names, PyList_GET_SIZE(value));
 966                 if (!object->names) { return -1;; }
 967                 talloc_set_name_const(object->names, "ARRAY: object->names");
 968                 for (names_cntr_0 = 0; names_cntr_0 < PyList_GET_SIZE(value); names_cntr_0++) {
 969                         PY_CHECK_TYPE(&nbt_status_name_Type, PyList_GET_ITEM(value, names_cntr_0), return -1;);
 970                         if (talloc_reference(object->names, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, names_cntr_0))) == NULL) {
 971                                 PyErr_NoMemory();
 972                                 return -1;
 973                         }
 974                         object->names[names_cntr_0] = *(struct nbt_status_name *)pytalloc_get_ptr(PyList_GET_ITEM(value, names_cntr_0));
 975                 }
 976         }
 977         return 0;
 978 }
 979
 980 static PyObject *py_nbt_rdata_status_get_statistics(PyObject *obj, void *closure)
 981 {
 982         struct nbt_rdata_status *object = (struct nbt_rdata_status *)pytalloc_get_ptr(obj);
 983         PyObject *py_statistics;
 984         py_statistics = pytalloc_reference_ex(&nbt_statistics_Type, pytalloc_get_mem_ctx(obj), &object->statistics);
 985         return py_statistics;
 986 }
 987
 988 static int py_nbt_rdata_status_set_statistics(PyObject *py_obj, PyObject *value, void *closure)
 989 {
 990         struct nbt_rdata_status *object = (struct nbt_rdata_status *)pytalloc_get_ptr(py_obj);
 991         PY_CHECK_TYPE(&nbt_statistics_Type, value, return -1;);
 992         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
 993                 PyErr_NoMemory();
 994                 return -1;
 995         }
 996         object->statistics = *(struct nbt_statistics *)pytalloc_get_ptr(value);
 997         return 0;
 998 }
 999
1000 static PyGetSetDef py_nbt_rdata_status_getsetters[] = {
1001         { discard_const_p(char, "length"), py_nbt_rdata_status_get_length, py_nbt_rdata_status_set_length },
1002         { discard_const_p(char, "num_names"), py_nbt_rdata_status_get_num_names, py_nbt_rdata_status_set_num_names },
1003         { discard_const_p(char, "names"), py_nbt_rdata_status_get_names, py_nbt_rdata_status_set_names },
1004         { discard_const_p(char, "statistics"), py_nbt_rdata_status_get_statistics, py_nbt_rdata_status_set_statistics },
1005         { NULL }
1006 };
1007
1008 static PyObject *py_nbt_rdata_status_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1009 {
1010         return pytalloc_new(struct nbt_rdata_status, type);
1011 }
1012
1013
1014 static PyTypeObject nbt_rdata_status_Type = {
1015         PyObject_HEAD_INIT(NULL) 0,
1016         .tp_name = "nbt.rdata_status",
1017         .tp_getset = py_nbt_rdata_status_getsetters,
1018         .tp_methods = NULL,
1019         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1020         .tp_basicsize = sizeof(pytalloc_Object),
1021         .tp_new = py_nbt_rdata_status_new,
1022 };
1023
1024
1025 static PyObject *py_nbt_rdata_data_get_length(PyObject *obj, void *closure)
1026 {
1027         struct nbt_rdata_data *object = (struct nbt_rdata_data *)pytalloc_get_ptr(obj);
1028         PyObject *py_length;
1029         py_length = PyInt_FromLong(object->length);
1030         return py_length;
1031 }
1032
1033 static int py_nbt_rdata_data_set_length(PyObject *py_obj, PyObject *value, void *closure)
1034 {
1035         struct nbt_rdata_data *object = (struct nbt_rdata_data *)pytalloc_get_ptr(py_obj);
1036         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1037         object->length = PyInt_AsLong(value);
1038         return 0;
1039 }
1040
1041 static PyObject *py_nbt_rdata_data_get_data(PyObject *obj, void *closure)
1042 {
1043         struct nbt_rdata_data *object = (struct nbt_rdata_data *)pytalloc_get_ptr(obj);
1044         PyObject *py_data;
1045         py_data = PyList_New(object->length);
1046         if (py_data == NULL) {
1047                 return NULL;
1048         }
1049         {
1050                 int data_cntr_0;
1051                 for (data_cntr_0 = 0; data_cntr_0 < object->length; data_cntr_0++) {
1052                         PyObject *py_data_0;
1053                         py_data_0 = PyInt_FromLong(object->data[data_cntr_0]);
1054                         PyList_SetItem(py_data, data_cntr_0, py_data_0);
1055                 }
1056         }
1057         return py_data;
1058 }
1059
1060 static int py_nbt_rdata_data_set_data(PyObject *py_obj, PyObject *value, void *closure)
1061 {
1062         struct nbt_rdata_data *object = (struct nbt_rdata_data *)pytalloc_get_ptr(py_obj);
1063         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
1064         {
1065                 int data_cntr_0;
1066                 object->data = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->data, PyList_GET_SIZE(value));
1067                 if (!object->data) { return -1;; }
1068                 talloc_set_name_const(object->data, "ARRAY: object->data");
1069                 for (data_cntr_0 = 0; data_cntr_0 < PyList_GET_SIZE(value); data_cntr_0++) {
1070                         PY_CHECK_TYPE(&PyInt_Type, PyList_GET_ITEM(value, data_cntr_0), return -1;);
1071                         object->data[data_cntr_0] = PyInt_AsLong(PyList_GET_ITEM(value, data_cntr_0));
1072                 }
1073         }
1074         return 0;
1075 }
1076
1077 static PyGetSetDef py_nbt_rdata_data_getsetters[] = {
1078         { discard_const_p(char, "length"), py_nbt_rdata_data_get_length, py_nbt_rdata_data_set_length },
1079         { discard_const_p(char, "data"), py_nbt_rdata_data_get_data, py_nbt_rdata_data_set_data },
1080         { NULL }
1081 };
1082
1083 static PyObject *py_nbt_rdata_data_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1084 {
1085         return pytalloc_new(struct nbt_rdata_data, type);
1086 }
1087
1088
1089 static PyTypeObject nbt_rdata_data_Type = {
1090         PyObject_HEAD_INIT(NULL) 0,
1091         .tp_name = "nbt.rdata_data",
1092         .tp_getset = py_nbt_rdata_data_getsetters,
1093         .tp_methods = NULL,
1094         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1095         .tp_basicsize = sizeof(pytalloc_Object),
1096         .tp_new = py_nbt_rdata_data_new,
1097 };
1098
1099 PyObject *py_import_nbt_rdata(TALLOC_CTX *mem_ctx, int level, union nbt_rdata *in)
1100 {
1101         PyObject *ret;
1102
1103         switch (level) {
1104                 case NBT_QTYPE_NETBIOS:
1105                         ret = pytalloc_reference_ex(&nbt_rdata_netbios_Type, mem_ctx, &in->netbios);
1106                         return ret;
1107
1108                 case NBT_QTYPE_STATUS:
1109                         ret = pytalloc_reference_ex(&nbt_rdata_status_Type, mem_ctx, &in->status);
1110                         return ret;
1111
1112                 default:
1113                         ret = pytalloc_reference_ex(&nbt_rdata_data_Type, mem_ctx, &in->data);
1114                         return ret;
1115
1116         }
1117         PyErr_SetString(PyExc_TypeError, "unknown union level");
1118         return NULL;
1119 }
1120
1121 union nbt_rdata *py_export_nbt_rdata(TALLOC_CTX *mem_ctx, int level, PyObject *in)
1122 {
1123         union nbt_rdata *ret = talloc_zero(mem_ctx, union nbt_rdata);
1124         switch (level) {
1125                 case NBT_QTYPE_NETBIOS:
1126                         PY_CHECK_TYPE(&nbt_rdata_netbios_Type, in, talloc_free(ret); return NULL;);
1127                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1128                                 PyErr_NoMemory();
1129                                 talloc_free(ret); return NULL;
1130                         }
1131                         ret->netbios = *(struct nbt_rdata_netbios *)pytalloc_get_ptr(in);
1132                         break;
1133
1134                 case NBT_QTYPE_STATUS:
1135                         PY_CHECK_TYPE(&nbt_rdata_status_Type, in, talloc_free(ret); return NULL;);
1136                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1137                                 PyErr_NoMemory();
1138                                 talloc_free(ret); return NULL;
1139                         }
1140                         ret->status = *(struct nbt_rdata_status *)pytalloc_get_ptr(in);
1141                         break;
1142
1143                 default:
1144                         PY_CHECK_TYPE(&nbt_rdata_data_Type, in, talloc_free(ret); return NULL;);
1145                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1146                                 PyErr_NoMemory();
1147                                 talloc_free(ret); return NULL;
1148                         }
1149                         ret->data = *(struct nbt_rdata_data *)pytalloc_get_ptr(in);
1150                         break;
1151
1152         }
1153
1154         return ret;
1155 }
1156
1157
1158 static PyObject *py_nbt_res_rec_get_name(PyObject *obj, void *closure)
1159 {
1160         struct nbt_res_rec *object = (struct nbt_res_rec *)pytalloc_get_ptr(obj);
1161         PyObject *py_name;
1162         py_name = pytalloc_reference_ex(&nbt_name_Type, pytalloc_get_mem_ctx(obj), &object->name);
1163         return py_name;
1164 }
1165
1166 static int py_nbt_res_rec_set_name(PyObject *py_obj, PyObject *value, void *closure)
1167 {
1168         struct nbt_res_rec *object = (struct nbt_res_rec *)pytalloc_get_ptr(py_obj);
1169         PY_CHECK_TYPE(&nbt_name_Type, value, return -1;);
1170         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
1171                 PyErr_NoMemory();
1172                 return -1;
1173         }
1174         object->name = *(struct nbt_name *)pytalloc_get_ptr(value);
1175         return 0;
1176 }
1177
1178 static PyObject *py_nbt_res_rec_get_rr_type(PyObject *obj, void *closure)
1179 {
1180         struct nbt_res_rec *object = (struct nbt_res_rec *)pytalloc_get_ptr(obj);
1181         PyObject *py_rr_type;
1182         py_rr_type = PyInt_FromLong(object->rr_type);
1183         return py_rr_type;
1184 }
1185
1186 static int py_nbt_res_rec_set_rr_type(PyObject *py_obj, PyObject *value, void *closure)
1187 {
1188         struct nbt_res_rec *object = (struct nbt_res_rec *)pytalloc_get_ptr(py_obj);
1189         if (PyLong_Check(value)) {
1190                 object->rr_type = PyLong_AsLongLong(value);
1191         } else if (PyInt_Check(value)) {
1192                 object->rr_type = PyInt_AsLong(value);
1193         } else {
1194                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1195                   PyInt_Type.tp_name, PyLong_Type.tp_name);
1196                 return -1;
1197         }
1198         return 0;
1199 }
1200
1201 static PyObject *py_nbt_res_rec_get_rr_class(PyObject *obj, void *closure)
1202 {
1203         struct nbt_res_rec *object = (struct nbt_res_rec *)pytalloc_get_ptr(obj);
1204         PyObject *py_rr_class;
1205         py_rr_class = PyInt_FromLong(object->rr_class);
1206         return py_rr_class;
1207 }
1208
1209 static int py_nbt_res_rec_set_rr_class(PyObject *py_obj, PyObject *value, void *closure)
1210 {
1211         struct nbt_res_rec *object = (struct nbt_res_rec *)pytalloc_get_ptr(py_obj);
1212         if (PyLong_Check(value)) {
1213                 object->rr_class = PyLong_AsLongLong(value);
1214         } else if (PyInt_Check(value)) {
1215                 object->rr_class = PyInt_AsLong(value);
1216         } else {
1217                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1218                   PyInt_Type.tp_name, PyLong_Type.tp_name);
1219                 return -1;
1220         }
1221         return 0;
1222 }
1223
1224 static PyObject *py_nbt_res_rec_get_ttl(PyObject *obj, void *closure)
1225 {
1226         struct nbt_res_rec *object = (struct nbt_res_rec *)pytalloc_get_ptr(obj);
1227         PyObject *py_ttl;
1228         py_ttl = PyInt_FromLong(object->ttl);
1229         return py_ttl;
1230 }
1231
1232 static int py_nbt_res_rec_set_ttl(PyObject *py_obj, PyObject *value, void *closure)
1233 {
1234         struct nbt_res_rec *object = (struct nbt_res_rec *)pytalloc_get_ptr(py_obj);
1235         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1236         object->ttl = PyInt_AsLong(value);
1237         return 0;
1238 }
1239
1240 static PyObject *py_nbt_res_rec_get_rdata(PyObject *obj, void *closure)
1241 {
1242         struct nbt_res_rec *object = (struct nbt_res_rec *)pytalloc_get_ptr(obj);
1243         PyObject *py_rdata;
1244         py_rdata = py_import_nbt_rdata(pytalloc_get_mem_ctx(obj), object->rr_type, &object->rdata);
1245         if (py_rdata == NULL) {
1246                 return NULL;
1247         }
1248         return py_rdata;
1249 }
1250
1251 static int py_nbt_res_rec_set_rdata(PyObject *py_obj, PyObject *value, void *closure)
1252 {
1253         struct nbt_res_rec *object = (struct nbt_res_rec *)pytalloc_get_ptr(py_obj);
1254         {
1255                 union nbt_rdata *rdata_switch_0;
1256                 rdata_switch_0 = py_export_nbt_rdata(pytalloc_get_mem_ctx(py_obj), object->rr_type, value);
1257                 if (rdata_switch_0 == NULL) {
1258                         return -1;
1259                 }
1260                 object->rdata = *rdata_switch_0;
1261         }
1262         return 0;
1263 }
1264
1265 static PyGetSetDef py_nbt_res_rec_getsetters[] = {
1266         { discard_const_p(char, "name"), py_nbt_res_rec_get_name, py_nbt_res_rec_set_name },
1267         { discard_const_p(char, "rr_type"), py_nbt_res_rec_get_rr_type, py_nbt_res_rec_set_rr_type },
1268         { discard_const_p(char, "rr_class"), py_nbt_res_rec_get_rr_class, py_nbt_res_rec_set_rr_class },
1269         { discard_const_p(char, "ttl"), py_nbt_res_rec_get_ttl, py_nbt_res_rec_set_ttl },
1270         { discard_const_p(char, "rdata"), py_nbt_res_rec_get_rdata, py_nbt_res_rec_set_rdata },
1271         { NULL }
1272 };
1273
1274 static PyObject *py_nbt_res_rec_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1275 {
1276         return pytalloc_new(struct nbt_res_rec, type);
1277 }
1278
1279
1280 static PyTypeObject nbt_res_rec_Type = {
1281         PyObject_HEAD_INIT(NULL) 0,
1282         .tp_name = "nbt.res_rec",
1283         .tp_getset = py_nbt_res_rec_getsetters,
1284         .tp_methods = NULL,
1285         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1286         .tp_basicsize = sizeof(pytalloc_Object),
1287         .tp_new = py_nbt_res_rec_new,
1288 };
1289
1290
1291 static PyObject *py_nbt_name_packet_get_name_trn_id(PyObject *obj, void *closure)
1292 {
1293         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(obj);
1294         PyObject *py_name_trn_id;
1295         py_name_trn_id = PyInt_FromLong(object->name_trn_id);
1296         return py_name_trn_id;
1297 }
1298
1299 static int py_nbt_name_packet_set_name_trn_id(PyObject *py_obj, PyObject *value, void *closure)
1300 {
1301         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(py_obj);
1302         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1303         object->name_trn_id = PyInt_AsLong(value);
1304         return 0;
1305 }
1306
1307 static PyObject *py_nbt_name_packet_get_operation(PyObject *obj, void *closure)
1308 {
1309         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(obj);
1310         PyObject *py_operation;
1311         py_operation = PyInt_FromLong(object->operation);
1312         return py_operation;
1313 }
1314
1315 static int py_nbt_name_packet_set_operation(PyObject *py_obj, PyObject *value, void *closure)
1316 {
1317         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(py_obj);
1318         if (PyLong_Check(value)) {
1319                 object->operation = PyLong_AsLongLong(value);
1320         } else if (PyInt_Check(value)) {
1321                 object->operation = PyInt_AsLong(value);
1322         } else {
1323                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1324                   PyInt_Type.tp_name, PyLong_Type.tp_name);
1325                 return -1;
1326         }
1327         return 0;
1328 }
1329
1330 static PyObject *py_nbt_name_packet_get_qdcount(PyObject *obj, void *closure)
1331 {
1332         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(obj);
1333         PyObject *py_qdcount;
1334         py_qdcount = PyInt_FromLong(object->qdcount);
1335         return py_qdcount;
1336 }
1337
1338 static int py_nbt_name_packet_set_qdcount(PyObject *py_obj, PyObject *value, void *closure)
1339 {
1340         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(py_obj);
1341         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1342         object->qdcount = PyInt_AsLong(value);
1343         return 0;
1344 }
1345
1346 static PyObject *py_nbt_name_packet_get_ancount(PyObject *obj, void *closure)
1347 {
1348         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(obj);
1349         PyObject *py_ancount;
1350         py_ancount = PyInt_FromLong(object->ancount);
1351         return py_ancount;
1352 }
1353
1354 static int py_nbt_name_packet_set_ancount(PyObject *py_obj, PyObject *value, void *closure)
1355 {
1356         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(py_obj);
1357         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1358         object->ancount = PyInt_AsLong(value);
1359         return 0;
1360 }
1361
1362 static PyObject *py_nbt_name_packet_get_nscount(PyObject *obj, void *closure)
1363 {
1364         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(obj);
1365         PyObject *py_nscount;
1366         py_nscount = PyInt_FromLong(object->nscount);
1367         return py_nscount;
1368 }
1369
1370 static int py_nbt_name_packet_set_nscount(PyObject *py_obj, PyObject *value, void *closure)
1371 {
1372         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(py_obj);
1373         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1374         object->nscount = PyInt_AsLong(value);
1375         return 0;
1376 }
1377
1378 static PyObject *py_nbt_name_packet_get_arcount(PyObject *obj, void *closure)
1379 {
1380         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(obj);
1381         PyObject *py_arcount;
1382         py_arcount = PyInt_FromLong(object->arcount);
1383         return py_arcount;
1384 }
1385
1386 static int py_nbt_name_packet_set_arcount(PyObject *py_obj, PyObject *value, void *closure)
1387 {
1388         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(py_obj);
1389         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1390         object->arcount = PyInt_AsLong(value);
1391         return 0;
1392 }
1393
1394 static PyObject *py_nbt_name_packet_get_questions(PyObject *obj, void *closure)
1395 {
1396         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(obj);
1397         PyObject *py_questions;
1398         py_questions = PyList_New(object->qdcount);
1399         if (py_questions == NULL) {
1400                 return NULL;
1401         }
1402         {
1403                 int questions_cntr_0;
1404                 for (questions_cntr_0 = 0; questions_cntr_0 < object->qdcount; questions_cntr_0++) {
1405                         PyObject *py_questions_0;
1406                         py_questions_0 = pytalloc_reference_ex(&nbt_name_question_Type, object->questions, &object->questions[questions_cntr_0]);
1407                         PyList_SetItem(py_questions, questions_cntr_0, py_questions_0);
1408                 }
1409         }
1410         return py_questions;
1411 }
1412
1413 static int py_nbt_name_packet_set_questions(PyObject *py_obj, PyObject *value, void *closure)
1414 {
1415         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(py_obj);
1416         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
1417         {
1418                 int questions_cntr_0;
1419                 object->questions = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->questions, PyList_GET_SIZE(value));
1420                 if (!object->questions) { return -1;; }
1421                 talloc_set_name_const(object->questions, "ARRAY: object->questions");
1422                 for (questions_cntr_0 = 0; questions_cntr_0 < PyList_GET_SIZE(value); questions_cntr_0++) {
1423                         PY_CHECK_TYPE(&nbt_name_question_Type, PyList_GET_ITEM(value, questions_cntr_0), return -1;);
1424                         if (talloc_reference(object->questions, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, questions_cntr_0))) == NULL) {
1425                                 PyErr_NoMemory();
1426                                 return -1;
1427                         }
1428                         object->questions[questions_cntr_0] = *(struct nbt_name_question *)pytalloc_get_ptr(PyList_GET_ITEM(value, questions_cntr_0));
1429                 }
1430         }
1431         return 0;
1432 }
1433
1434 static PyObject *py_nbt_name_packet_get_answers(PyObject *obj, void *closure)
1435 {
1436         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(obj);
1437         PyObject *py_answers;
1438         py_answers = PyList_New(object->ancount);
1439         if (py_answers == NULL) {
1440                 return NULL;
1441         }
1442         {
1443                 int answers_cntr_0;
1444                 for (answers_cntr_0 = 0; answers_cntr_0 < object->ancount; answers_cntr_0++) {
1445                         PyObject *py_answers_0;
1446                         py_answers_0 = pytalloc_reference_ex(&nbt_res_rec_Type, object->answers, &object->answers[answers_cntr_0]);
1447                         PyList_SetItem(py_answers, answers_cntr_0, py_answers_0);
1448                 }
1449         }
1450         return py_answers;
1451 }
1452
1453 static int py_nbt_name_packet_set_answers(PyObject *py_obj, PyObject *value, void *closure)
1454 {
1455         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(py_obj);
1456         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
1457         {
1458                 int answers_cntr_0;
1459                 object->answers = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->answers, PyList_GET_SIZE(value));
1460                 if (!object->answers) { return -1;; }
1461                 talloc_set_name_const(object->answers, "ARRAY: object->answers");
1462                 for (answers_cntr_0 = 0; answers_cntr_0 < PyList_GET_SIZE(value); answers_cntr_0++) {
1463                         PY_CHECK_TYPE(&nbt_res_rec_Type, PyList_GET_ITEM(value, answers_cntr_0), return -1;);
1464                         if (talloc_reference(object->answers, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, answers_cntr_0))) == NULL) {
1465                                 PyErr_NoMemory();
1466                                 return -1;
1467                         }
1468                         object->answers[answers_cntr_0] = *(struct nbt_res_rec *)pytalloc_get_ptr(PyList_GET_ITEM(value, answers_cntr_0));
1469                 }
1470         }
1471         return 0;
1472 }
1473
1474 static PyObject *py_nbt_name_packet_get_nsrecs(PyObject *obj, void *closure)
1475 {
1476         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(obj);
1477         PyObject *py_nsrecs;
1478         py_nsrecs = PyList_New(object->nscount);
1479         if (py_nsrecs == NULL) {
1480                 return NULL;
1481         }
1482         {
1483                 int nsrecs_cntr_0;
1484                 for (nsrecs_cntr_0 = 0; nsrecs_cntr_0 < object->nscount; nsrecs_cntr_0++) {
1485                         PyObject *py_nsrecs_0;
1486                         py_nsrecs_0 = pytalloc_reference_ex(&nbt_res_rec_Type, object->nsrecs, &object->nsrecs[nsrecs_cntr_0]);
1487                         PyList_SetItem(py_nsrecs, nsrecs_cntr_0, py_nsrecs_0);
1488                 }
1489         }
1490         return py_nsrecs;
1491 }
1492
1493 static int py_nbt_name_packet_set_nsrecs(PyObject *py_obj, PyObject *value, void *closure)
1494 {
1495         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(py_obj);
1496         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
1497         {
1498                 int nsrecs_cntr_0;
1499                 object->nsrecs = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->nsrecs, PyList_GET_SIZE(value));
1500                 if (!object->nsrecs) { return -1;; }
1501                 talloc_set_name_const(object->nsrecs, "ARRAY: object->nsrecs");
1502                 for (nsrecs_cntr_0 = 0; nsrecs_cntr_0 < PyList_GET_SIZE(value); nsrecs_cntr_0++) {
1503                         PY_CHECK_TYPE(&nbt_res_rec_Type, PyList_GET_ITEM(value, nsrecs_cntr_0), return -1;);
1504                         if (talloc_reference(object->nsrecs, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, nsrecs_cntr_0))) == NULL) {
1505                                 PyErr_NoMemory();
1506                                 return -1;
1507                         }
1508                         object->nsrecs[nsrecs_cntr_0] = *(struct nbt_res_rec *)pytalloc_get_ptr(PyList_GET_ITEM(value, nsrecs_cntr_0));
1509                 }
1510         }
1511         return 0;
1512 }
1513
1514 static PyObject *py_nbt_name_packet_get_additional(PyObject *obj, void *closure)
1515 {
1516         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(obj);
1517         PyObject *py_additional;
1518         py_additional = PyList_New(object->arcount);
1519         if (py_additional == NULL) {
1520                 return NULL;
1521         }
1522         {
1523                 int additional_cntr_0;
1524                 for (additional_cntr_0 = 0; additional_cntr_0 < object->arcount; additional_cntr_0++) {
1525                         PyObject *py_additional_0;
1526                         py_additional_0 = pytalloc_reference_ex(&nbt_res_rec_Type, object->additional, &object->additional[additional_cntr_0]);
1527                         PyList_SetItem(py_additional, additional_cntr_0, py_additional_0);
1528                 }
1529         }
1530         return py_additional;
1531 }
1532
1533 static int py_nbt_name_packet_set_additional(PyObject *py_obj, PyObject *value, void *closure)
1534 {
1535         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(py_obj);
1536         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
1537         {
1538                 int additional_cntr_0;
1539                 object->additional = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->additional, PyList_GET_SIZE(value));
1540                 if (!object->additional) { return -1;; }
1541                 talloc_set_name_const(object->additional, "ARRAY: object->additional");
1542                 for (additional_cntr_0 = 0; additional_cntr_0 < PyList_GET_SIZE(value); additional_cntr_0++) {
1543                         PY_CHECK_TYPE(&nbt_res_rec_Type, PyList_GET_ITEM(value, additional_cntr_0), return -1;);
1544                         if (talloc_reference(object->additional, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, additional_cntr_0))) == NULL) {
1545                                 PyErr_NoMemory();
1546                                 return -1;
1547                         }
1548                         object->additional[additional_cntr_0] = *(struct nbt_res_rec *)pytalloc_get_ptr(PyList_GET_ITEM(value, additional_cntr_0));
1549                 }
1550         }
1551         return 0;
1552 }
1553
1554 static PyObject *py_nbt_name_packet_get_padding(PyObject *obj, void *closure)
1555 {
1556         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(obj);
1557         PyObject *py_padding;
1558         py_padding = PyString_FromStringAndSize((char *)(object->padding).data, (object->padding).length);
1559         return py_padding;
1560 }
1561
1562 static int py_nbt_name_packet_set_padding(PyObject *py_obj, PyObject *value, void *closure)
1563 {
1564         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(py_obj);
1565         object->padding = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value), PyString_GET_SIZE(value));
1566         return 0;
1567 }
1568
1569 static PyGetSetDef py_nbt_name_packet_getsetters[] = {
1570         { discard_const_p(char, "name_trn_id"), py_nbt_name_packet_get_name_trn_id, py_nbt_name_packet_set_name_trn_id },
1571         { discard_const_p(char, "operation"), py_nbt_name_packet_get_operation, py_nbt_name_packet_set_operation },
1572         { discard_const_p(char, "qdcount"), py_nbt_name_packet_get_qdcount, py_nbt_name_packet_set_qdcount },
1573         { discard_const_p(char, "ancount"), py_nbt_name_packet_get_ancount, py_nbt_name_packet_set_ancount },
1574         { discard_const_p(char, "nscount"), py_nbt_name_packet_get_nscount, py_nbt_name_packet_set_nscount },
1575         { discard_const_p(char, "arcount"), py_nbt_name_packet_get_arcount, py_nbt_name_packet_set_arcount },
1576         { discard_const_p(char, "questions"), py_nbt_name_packet_get_questions, py_nbt_name_packet_set_questions },
1577         { discard_const_p(char, "answers"), py_nbt_name_packet_get_answers, py_nbt_name_packet_set_answers },
1578         { discard_const_p(char, "nsrecs"), py_nbt_name_packet_get_nsrecs, py_nbt_name_packet_set_nsrecs },
1579         { discard_const_p(char, "additional"), py_nbt_name_packet_get_additional, py_nbt_name_packet_set_additional },
1580         { discard_const_p(char, "padding"), py_nbt_name_packet_get_padding, py_nbt_name_packet_set_padding },
1581         { NULL }
1582 };
1583
1584 static PyObject *py_nbt_name_packet_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1585 {
1586         return pytalloc_new(struct nbt_name_packet, type);
1587 }
1588
1589 static PyObject *py_nbt_name_packet_ndr_pack(PyObject *py_obj)
1590 {
1591         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(py_obj);
1592         DATA_BLOB blob;
1593         enum ndr_err_code err;
1594         err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_nbt_name_packet);
1595         if (err != NDR_ERR_SUCCESS) {
1596                 PyErr_SetNdrError(err);
1597                 return NULL;
1598         }
1599
1600         return PyString_FromStringAndSize((char *)blob.data, blob.length);
1601 }
1602
1603 static PyObject *py_nbt_name_packet_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
1604 {
1605         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(py_obj);
1606         DATA_BLOB blob;
1607         int blob_length = 0;
1608         enum ndr_err_code err;
1609         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
1610         PyObject *allow_remaining_obj = NULL;
1611         bool allow_remaining = false;
1612
1613         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
1614                 discard_const_p(char *, kwnames),
1615                 &blob.data, &blob_length,
1616                 &allow_remaining_obj)) {
1617                 return NULL;
1618         }
1619         blob.length = blob_length;
1620
1621         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
1622                 allow_remaining = true;
1623         }
1624
1625         if (allow_remaining) {
1626                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_nbt_name_packet);
1627         } else {
1628                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_nbt_name_packet);
1629         }
1630         if (err != NDR_ERR_SUCCESS) {
1631                 PyErr_SetNdrError(err);
1632                 return NULL;
1633         }
1634
1635         Py_RETURN_NONE;
1636 }
1637
1638 static PyObject *py_nbt_name_packet_ndr_print(PyObject *py_obj)
1639 {
1640         struct nbt_name_packet *object = (struct nbt_name_packet *)pytalloc_get_ptr(py_obj);
1641         PyObject *ret;
1642         char *retstr;
1643
1644         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_nbt_name_packet, "nbt_name_packet", object);
1645         ret = PyString_FromString(retstr);
1646         talloc_free(retstr);
1647
1648         return ret;
1649 }
1650
1651 static PyMethodDef py_nbt_name_packet_methods[] = {
1652         { "__ndr_pack__", (PyCFunction)py_nbt_name_packet_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
1653         { "__ndr_unpack__", (PyCFunction)py_nbt_name_packet_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
1654         { "__ndr_print__", (PyCFunction)py_nbt_name_packet_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
1655         { NULL, NULL, 0, NULL }
1656 };
1657
1658
1659 static PyTypeObject nbt_name_packet_Type = {
1660         PyObject_HEAD_INIT(NULL) 0,
1661         .tp_name = "nbt.name_packet",
1662         .tp_getset = py_nbt_name_packet_getsetters,
1663         .tp_methods = py_nbt_name_packet_methods,
1664         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1665         .tp_basicsize = sizeof(pytalloc_Object),
1666         .tp_new = py_nbt_name_packet_new,
1667 };
1668
1669
1670 static PyObject *py_smb_trans_body_get_wct(PyObject *obj, void *closure)
1671 {
1672         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(obj);
1673         PyObject *py_wct;
1674         py_wct = PyInt_FromLong(object->wct);
1675         return py_wct;
1676 }
1677
1678 static int py_smb_trans_body_set_wct(PyObject *py_obj, PyObject *value, void *closure)
1679 {
1680         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(py_obj);
1681         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1682         object->wct = PyInt_AsLong(value);
1683         return 0;
1684 }
1685
1686 static PyObject *py_smb_trans_body_get_total_param_count(PyObject *obj, void *closure)
1687 {
1688         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(obj);
1689         PyObject *py_total_param_count;
1690         py_total_param_count = PyInt_FromLong(object->total_param_count);
1691         return py_total_param_count;
1692 }
1693
1694 static int py_smb_trans_body_set_total_param_count(PyObject *py_obj, PyObject *value, void *closure)
1695 {
1696         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(py_obj);
1697         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1698         object->total_param_count = PyInt_AsLong(value);
1699         return 0;
1700 }
1701
1702 static PyObject *py_smb_trans_body_get_total_data_count(PyObject *obj, void *closure)
1703 {
1704         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(obj);
1705         PyObject *py_total_data_count;
1706         py_total_data_count = PyInt_FromLong(object->total_data_count);
1707         return py_total_data_count;
1708 }
1709
1710 static int py_smb_trans_body_set_total_data_count(PyObject *py_obj, PyObject *value, void *closure)
1711 {
1712         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(py_obj);
1713         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1714         object->total_data_count = PyInt_AsLong(value);
1715         return 0;
1716 }
1717
1718 static PyObject *py_smb_trans_body_get_max_param_count(PyObject *obj, void *closure)
1719 {
1720         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(obj);
1721         PyObject *py_max_param_count;
1722         py_max_param_count = PyInt_FromLong(object->max_param_count);
1723         return py_max_param_count;
1724 }
1725
1726 static int py_smb_trans_body_set_max_param_count(PyObject *py_obj, PyObject *value, void *closure)
1727 {
1728         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(py_obj);
1729         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1730         object->max_param_count = PyInt_AsLong(value);
1731         return 0;
1732 }
1733
1734 static PyObject *py_smb_trans_body_get_max_data_count(PyObject *obj, void *closure)
1735 {
1736         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(obj);
1737         PyObject *py_max_data_count;
1738         py_max_data_count = PyInt_FromLong(object->max_data_count);
1739         return py_max_data_count;
1740 }
1741
1742 static int py_smb_trans_body_set_max_data_count(PyObject *py_obj, PyObject *value, void *closure)
1743 {
1744         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(py_obj);
1745         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1746         object->max_data_count = PyInt_AsLong(value);
1747         return 0;
1748 }
1749
1750 static PyObject *py_smb_trans_body_get_max_setup_count(PyObject *obj, void *closure)
1751 {
1752         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(obj);
1753         PyObject *py_max_setup_count;
1754         py_max_setup_count = PyInt_FromLong(object->max_setup_count);
1755         return py_max_setup_count;
1756 }
1757
1758 static int py_smb_trans_body_set_max_setup_count(PyObject *py_obj, PyObject *value, void *closure)
1759 {
1760         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(py_obj);
1761         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1762         object->max_setup_count = PyInt_AsLong(value);
1763         return 0;
1764 }
1765
1766 static PyObject *py_smb_trans_body_get_pad(PyObject *obj, void *closure)
1767 {
1768         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(obj);
1769         PyObject *py_pad;
1770         py_pad = PyInt_FromLong(object->pad);
1771         return py_pad;
1772 }
1773
1774 static int py_smb_trans_body_set_pad(PyObject *py_obj, PyObject *value, void *closure)
1775 {
1776         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(py_obj);
1777         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1778         object->pad = PyInt_AsLong(value);
1779         return 0;
1780 }
1781
1782 static PyObject *py_smb_trans_body_get_trans_flags(PyObject *obj, void *closure)
1783 {
1784         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(obj);
1785         PyObject *py_trans_flags;
1786         py_trans_flags = PyInt_FromLong(object->trans_flags);
1787         return py_trans_flags;
1788 }
1789
1790 static int py_smb_trans_body_set_trans_flags(PyObject *py_obj, PyObject *value, void *closure)
1791 {
1792         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(py_obj);
1793         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1794         object->trans_flags = PyInt_AsLong(value);
1795         return 0;
1796 }
1797
1798 static PyObject *py_smb_trans_body_get_timeout(PyObject *obj, void *closure)
1799 {
1800         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(obj);
1801         PyObject *py_timeout;
1802         py_timeout = PyInt_FromLong(object->timeout);
1803         return py_timeout;
1804 }
1805
1806 static int py_smb_trans_body_set_timeout(PyObject *py_obj, PyObject *value, void *closure)
1807 {
1808         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(py_obj);
1809         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1810         object->timeout = PyInt_AsLong(value);
1811         return 0;
1812 }
1813
1814 static PyObject *py_smb_trans_body_get_reserved(PyObject *obj, void *closure)
1815 {
1816         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(obj);
1817         PyObject *py_reserved;
1818         py_reserved = PyInt_FromLong(object->reserved);
1819         return py_reserved;
1820 }
1821
1822 static int py_smb_trans_body_set_reserved(PyObject *py_obj, PyObject *value, void *closure)
1823 {
1824         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(py_obj);
1825         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1826         object->reserved = PyInt_AsLong(value);
1827         return 0;
1828 }
1829
1830 static PyObject *py_smb_trans_body_get_param_count(PyObject *obj, void *closure)
1831 {
1832         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(obj);
1833         PyObject *py_param_count;
1834         py_param_count = PyInt_FromLong(object->param_count);
1835         return py_param_count;
1836 }
1837
1838 static int py_smb_trans_body_set_param_count(PyObject *py_obj, PyObject *value, void *closure)
1839 {
1840         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(py_obj);
1841         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1842         object->param_count = PyInt_AsLong(value);
1843         return 0;
1844 }
1845
1846 static PyObject *py_smb_trans_body_get_param_offset(PyObject *obj, void *closure)
1847 {
1848         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(obj);
1849         PyObject *py_param_offset;
1850         py_param_offset = PyInt_FromLong(object->param_offset);
1851         return py_param_offset;
1852 }
1853
1854 static int py_smb_trans_body_set_param_offset(PyObject *py_obj, PyObject *value, void *closure)
1855 {
1856         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(py_obj);
1857         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1858         object->param_offset = PyInt_AsLong(value);
1859         return 0;
1860 }
1861
1862 static PyObject *py_smb_trans_body_get_data_count(PyObject *obj, void *closure)
1863 {
1864         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(obj);
1865         PyObject *py_data_count;
1866         py_data_count = PyInt_FromLong(object->data_count);
1867         return py_data_count;
1868 }
1869
1870 static int py_smb_trans_body_set_data_count(PyObject *py_obj, PyObject *value, void *closure)
1871 {
1872         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(py_obj);
1873         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1874         object->data_count = PyInt_AsLong(value);
1875         return 0;
1876 }
1877
1878 static PyObject *py_smb_trans_body_get_data_offset(PyObject *obj, void *closure)
1879 {
1880         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(obj);
1881         PyObject *py_data_offset;
1882         py_data_offset = PyInt_FromLong(object->data_offset);
1883         return py_data_offset;
1884 }
1885
1886 static int py_smb_trans_body_set_data_offset(PyObject *py_obj, PyObject *value, void *closure)
1887 {
1888         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(py_obj);
1889         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1890         object->data_offset = PyInt_AsLong(value);
1891         return 0;
1892 }
1893
1894 static PyObject *py_smb_trans_body_get_setup_count(PyObject *obj, void *closure)
1895 {
1896         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(obj);
1897         PyObject *py_setup_count;
1898         py_setup_count = PyInt_FromLong(object->setup_count);
1899         return py_setup_count;
1900 }
1901
1902 static int py_smb_trans_body_set_setup_count(PyObject *py_obj, PyObject *value, void *closure)
1903 {
1904         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(py_obj);
1905         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1906         object->setup_count = PyInt_AsLong(value);
1907         return 0;
1908 }
1909
1910 static PyObject *py_smb_trans_body_get_pad2(PyObject *obj, void *closure)
1911 {
1912         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(obj);
1913         PyObject *py_pad2;
1914         py_pad2 = PyInt_FromLong(object->pad2);
1915         return py_pad2;
1916 }
1917
1918 static int py_smb_trans_body_set_pad2(PyObject *py_obj, PyObject *value, void *closure)
1919 {
1920         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(py_obj);
1921         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1922         object->pad2 = PyInt_AsLong(value);
1923         return 0;
1924 }
1925
1926 static PyObject *py_smb_trans_body_get_opcode(PyObject *obj, void *closure)
1927 {
1928         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(obj);
1929         PyObject *py_opcode;
1930         py_opcode = PyInt_FromLong(object->opcode);
1931         return py_opcode;
1932 }
1933
1934 static int py_smb_trans_body_set_opcode(PyObject *py_obj, PyObject *value, void *closure)
1935 {
1936         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(py_obj);
1937         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1938         object->opcode = PyInt_AsLong(value);
1939         return 0;
1940 }
1941
1942 static PyObject *py_smb_trans_body_get_priority(PyObject *obj, void *closure)
1943 {
1944         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(obj);
1945         PyObject *py_priority;
1946         py_priority = PyInt_FromLong(object->priority);
1947         return py_priority;
1948 }
1949
1950 static int py_smb_trans_body_set_priority(PyObject *py_obj, PyObject *value, void *closure)
1951 {
1952         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(py_obj);
1953         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1954         object->priority = PyInt_AsLong(value);
1955         return 0;
1956 }
1957
1958 static PyObject *py_smb_trans_body_get__class(PyObject *obj, void *closure)
1959 {
1960         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(obj);
1961         PyObject *py__class;
1962         py__class = PyInt_FromLong(object->_class);
1963         return py__class;
1964 }
1965
1966 static int py_smb_trans_body_set__class(PyObject *py_obj, PyObject *value, void *closure)
1967 {
1968         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(py_obj);
1969         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1970         object->_class = PyInt_AsLong(value);
1971         return 0;
1972 }
1973
1974 static PyObject *py_smb_trans_body_get_byte_count(PyObject *obj, void *closure)
1975 {
1976         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(obj);
1977         PyObject *py_byte_count;
1978         py_byte_count = PyInt_FromLong(object->byte_count);
1979         return py_byte_count;
1980 }
1981
1982 static int py_smb_trans_body_set_byte_count(PyObject *py_obj, PyObject *value, void *closure)
1983 {
1984         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(py_obj);
1985         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1986         object->byte_count = PyInt_AsLong(value);
1987         return 0;
1988 }
1989
1990 static PyObject *py_smb_trans_body_get_mailslot_name(PyObject *obj, void *closure)
1991 {
1992         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(obj);
1993         PyObject *py_mailslot_name;
1994         py_mailslot_name = PyString_FromStringOrNULL(object->mailslot_name);
1995         return py_mailslot_name;
1996 }
1997
1998 static int py_smb_trans_body_set_mailslot_name(PyObject *py_obj, PyObject *value, void *closure)
1999 {
2000         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(py_obj);
2001         object->mailslot_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
2002         return 0;
2003 }
2004
2005 static PyObject *py_smb_trans_body_get_data(PyObject *obj, void *closure)
2006 {
2007         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(obj);
2008         PyObject *py_data;
2009         py_data = PyString_FromStringAndSize((char *)(object->data).data, (object->data).length);
2010         return py_data;
2011 }
2012
2013 static int py_smb_trans_body_set_data(PyObject *py_obj, PyObject *value, void *closure)
2014 {
2015         struct smb_trans_body *object = (struct smb_trans_body *)pytalloc_get_ptr(py_obj);
2016         object->data = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value), PyString_GET_SIZE(value));
2017         return 0;
2018 }
2019
2020 static PyGetSetDef py_smb_trans_body_getsetters[] = {
2021         { discard_const_p(char, "wct"), py_smb_trans_body_get_wct, py_smb_trans_body_set_wct },
2022         { discard_const_p(char, "total_param_count"), py_smb_trans_body_get_total_param_count, py_smb_trans_body_set_total_param_count },
2023         { discard_const_p(char, "total_data_count"), py_smb_trans_body_get_total_data_count, py_smb_trans_body_set_total_data_count },
2024         { discard_const_p(char, "max_param_count"), py_smb_trans_body_get_max_param_count, py_smb_trans_body_set_max_param_count },
2025         { discard_const_p(char, "max_data_count"), py_smb_trans_body_get_max_data_count, py_smb_trans_body_set_max_data_count },
2026         { discard_const_p(char, "max_setup_count"), py_smb_trans_body_get_max_setup_count, py_smb_trans_body_set_max_setup_count },
2027         { discard_const_p(char, "pad"), py_smb_trans_body_get_pad, py_smb_trans_body_set_pad },
2028         { discard_const_p(char, "trans_flags"), py_smb_trans_body_get_trans_flags, py_smb_trans_body_set_trans_flags },
2029         { discard_const_p(char, "timeout"), py_smb_trans_body_get_timeout, py_smb_trans_body_set_timeout },
2030         { discard_const_p(char, "reserved"), py_smb_trans_body_get_reserved, py_smb_trans_body_set_reserved },
2031         { discard_const_p(char, "param_count"), py_smb_trans_body_get_param_count, py_smb_trans_body_set_param_count },
2032         { discard_const_p(char, "param_offset"), py_smb_trans_body_get_param_offset, py_smb_trans_body_set_param_offset },
2033         { discard_const_p(char, "data_count"), py_smb_trans_body_get_data_count, py_smb_trans_body_set_data_count },
2034         { discard_const_p(char, "data_offset"), py_smb_trans_body_get_data_offset, py_smb_trans_body_set_data_offset },
2035         { discard_const_p(char, "setup_count"), py_smb_trans_body_get_setup_count, py_smb_trans_body_set_setup_count },
2036         { discard_const_p(char, "pad2"), py_smb_trans_body_get_pad2, py_smb_trans_body_set_pad2 },
2037         { discard_const_p(char, "opcode"), py_smb_trans_body_get_opcode, py_smb_trans_body_set_opcode },
2038         { discard_const_p(char, "priority"), py_smb_trans_body_get_priority, py_smb_trans_body_set_priority },
2039         { discard_const_p(char, "_class"), py_smb_trans_body_get__class, py_smb_trans_body_set__class },
2040         { discard_const_p(char, "byte_count"), py_smb_trans_body_get_byte_count, py_smb_trans_body_set_byte_count },
2041         { discard_const_p(char, "mailslot_name"), py_smb_trans_body_get_mailslot_name, py_smb_trans_body_set_mailslot_name },
2042         { discard_const_p(char, "data"), py_smb_trans_body_get_data, py_smb_trans_body_set_data },
2043         { NULL }
2044 };
2045
2046 static PyObject *py_smb_trans_body_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2047 {
2048         return pytalloc_new(struct smb_trans_body, type);
2049 }
2050
2051
2052 static PyTypeObject smb_trans_body_Type = {
2053         PyObject_HEAD_INIT(NULL) 0,
2054         .tp_name = "nbt.smb_trans_body",
2055         .tp_getset = py_smb_trans_body_getsetters,
2056         .tp_methods = NULL,
2057         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2058         .tp_basicsize = sizeof(pytalloc_Object),
2059         .tp_new = py_smb_trans_body_new,
2060 };
2061
2062 PyObject *py_import_smb_body(TALLOC_CTX *mem_ctx, int level, union smb_body *in)
2063 {
2064         PyObject *ret;
2065
2066         switch (level) {
2067                 case SMB_TRANSACTION:
2068                         ret = pytalloc_reference_ex(&smb_trans_body_Type, mem_ctx, &in->trans);
2069                         return ret;
2070
2071         }
2072         PyErr_SetString(PyExc_TypeError, "unknown union level");
2073         return NULL;
2074 }
2075
2076 union smb_body *py_export_smb_body(TALLOC_CTX *mem_ctx, int level, PyObject *in)
2077 {
2078         union smb_body *ret = talloc_zero(mem_ctx, union smb_body);
2079         switch (level) {
2080                 case SMB_TRANSACTION:
2081                         PY_CHECK_TYPE(&smb_trans_body_Type, in, talloc_free(ret); return NULL;);
2082                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
2083                                 PyErr_NoMemory();
2084                                 talloc_free(ret); return NULL;
2085                         }
2086                         ret->trans = *(struct smb_trans_body *)pytalloc_get_ptr(in);
2087                         break;
2088
2089                 default:
2090                         PyErr_SetString(PyExc_TypeError, "invalid union level value");
2091                         talloc_free(ret);
2092                         ret = NULL;
2093         }
2094
2095         return ret;
2096 }
2097
2098
2099 static PyObject *py_dgram_smb_packet_get_smb_command(PyObject *obj, void *closure)
2100 {
2101         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(obj);
2102         PyObject *py_smb_command;
2103         py_smb_command = PyInt_FromLong(object->smb_command);
2104         return py_smb_command;
2105 }
2106
2107 static int py_dgram_smb_packet_set_smb_command(PyObject *py_obj, PyObject *value, void *closure)
2108 {
2109         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(py_obj);
2110         if (PyLong_Check(value)) {
2111                 object->smb_command = PyLong_AsLongLong(value);
2112         } else if (PyInt_Check(value)) {
2113                 object->smb_command = PyInt_AsLong(value);
2114         } else {
2115                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
2116                   PyInt_Type.tp_name, PyLong_Type.tp_name);
2117                 return -1;
2118         }
2119         return 0;
2120 }
2121
2122 static PyObject *py_dgram_smb_packet_get_err_class(PyObject *obj, void *closure)
2123 {
2124         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(obj);
2125         PyObject *py_err_class;
2126         py_err_class = PyInt_FromLong(object->err_class);
2127         return py_err_class;
2128 }
2129
2130 static int py_dgram_smb_packet_set_err_class(PyObject *py_obj, PyObject *value, void *closure)
2131 {
2132         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(py_obj);
2133         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2134         object->err_class = PyInt_AsLong(value);
2135         return 0;
2136 }
2137
2138 static PyObject *py_dgram_smb_packet_get_pad(PyObject *obj, void *closure)
2139 {
2140         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(obj);
2141         PyObject *py_pad;
2142         py_pad = PyInt_FromLong(object->pad);
2143         return py_pad;
2144 }
2145
2146 static int py_dgram_smb_packet_set_pad(PyObject *py_obj, PyObject *value, void *closure)
2147 {
2148         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(py_obj);
2149         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2150         object->pad = PyInt_AsLong(value);
2151         return 0;
2152 }
2153
2154 static PyObject *py_dgram_smb_packet_get_err_code(PyObject *obj, void *closure)
2155 {
2156         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(obj);
2157         PyObject *py_err_code;
2158         py_err_code = PyInt_FromLong(object->err_code);
2159         return py_err_code;
2160 }
2161
2162 static int py_dgram_smb_packet_set_err_code(PyObject *py_obj, PyObject *value, void *closure)
2163 {
2164         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(py_obj);
2165         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2166         object->err_code = PyInt_AsLong(value);
2167         return 0;
2168 }
2169
2170 static PyObject *py_dgram_smb_packet_get_flags(PyObject *obj, void *closure)
2171 {
2172         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(obj);
2173         PyObject *py_flags;
2174         py_flags = PyInt_FromLong(object->flags);
2175         return py_flags;
2176 }
2177
2178 static int py_dgram_smb_packet_set_flags(PyObject *py_obj, PyObject *value, void *closure)
2179 {
2180         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(py_obj);
2181         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2182         object->flags = PyInt_AsLong(value);
2183         return 0;
2184 }
2185
2186 static PyObject *py_dgram_smb_packet_get_flags2(PyObject *obj, void *closure)
2187 {
2188         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(obj);
2189         PyObject *py_flags2;
2190         py_flags2 = PyInt_FromLong(object->flags2);
2191         return py_flags2;
2192 }
2193
2194 static int py_dgram_smb_packet_set_flags2(PyObject *py_obj, PyObject *value, void *closure)
2195 {
2196         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(py_obj);
2197         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2198         object->flags2 = PyInt_AsLong(value);
2199         return 0;
2200 }
2201
2202 static PyObject *py_dgram_smb_packet_get_pid_high(PyObject *obj, void *closure)
2203 {
2204         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(obj);
2205         PyObject *py_pid_high;
2206         py_pid_high = PyInt_FromLong(object->pid_high);
2207         return py_pid_high;
2208 }
2209
2210 static int py_dgram_smb_packet_set_pid_high(PyObject *py_obj, PyObject *value, void *closure)
2211 {
2212         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(py_obj);
2213         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2214         object->pid_high = PyInt_AsLong(value);
2215         return 0;
2216 }
2217
2218 static PyObject *py_dgram_smb_packet_get_signature(PyObject *obj, void *closure)
2219 {
2220         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(obj);
2221         PyObject *py_signature;
2222         py_signature = PyList_New(8);
2223         if (py_signature == NULL) {
2224                 return NULL;
2225         }
2226         {
2227                 int signature_cntr_0;
2228                 for (signature_cntr_0 = 0; signature_cntr_0 < 8; signature_cntr_0++) {
2229                         PyObject *py_signature_0;
2230                         py_signature_0 = PyInt_FromLong(object->signature[signature_cntr_0]);
2231                         PyList_SetItem(py_signature, signature_cntr_0, py_signature_0);
2232                 }
2233         }
2234         return py_signature;
2235 }
2236
2237 static int py_dgram_smb_packet_set_signature(PyObject *py_obj, PyObject *value, void *closure)
2238 {
2239         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(py_obj);
2240         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
2241         {
2242                 int signature_cntr_0;
2243                 for (signature_cntr_0 = 0; signature_cntr_0 < PyList_GET_SIZE(value); signature_cntr_0++) {
2244                         PY_CHECK_TYPE(&PyInt_Type, PyList_GET_ITEM(value, signature_cntr_0), return -1;);
2245                         object->signature[signature_cntr_0] = PyInt_AsLong(PyList_GET_ITEM(value, signature_cntr_0));
2246                 }
2247         }
2248         return 0;
2249 }
2250
2251 static PyObject *py_dgram_smb_packet_get_reserved(PyObject *obj, void *closure)
2252 {
2253         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(obj);
2254         PyObject *py_reserved;
2255         py_reserved = PyInt_FromLong(object->reserved);
2256         return py_reserved;
2257 }
2258
2259 static int py_dgram_smb_packet_set_reserved(PyObject *py_obj, PyObject *value, void *closure)
2260 {
2261         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(py_obj);
2262         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2263         object->reserved = PyInt_AsLong(value);
2264         return 0;
2265 }
2266
2267 static PyObject *py_dgram_smb_packet_get_tid(PyObject *obj, void *closure)
2268 {
2269         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(obj);
2270         PyObject *py_tid;
2271         py_tid = PyInt_FromLong(object->tid);
2272         return py_tid;
2273 }
2274
2275 static int py_dgram_smb_packet_set_tid(PyObject *py_obj, PyObject *value, void *closure)
2276 {
2277         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(py_obj);
2278         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2279         object->tid = PyInt_AsLong(value);
2280         return 0;
2281 }
2282
2283 static PyObject *py_dgram_smb_packet_get_pid(PyObject *obj, void *closure)
2284 {
2285         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(obj);
2286         PyObject *py_pid;
2287         py_pid = PyInt_FromLong(object->pid);
2288         return py_pid;
2289 }
2290
2291 static int py_dgram_smb_packet_set_pid(PyObject *py_obj, PyObject *value, void *closure)
2292 {
2293         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(py_obj);
2294         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2295         object->pid = PyInt_AsLong(value);
2296         return 0;
2297 }
2298
2299 static PyObject *py_dgram_smb_packet_get_vuid(PyObject *obj, void *closure)
2300 {
2301         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(obj);
2302         PyObject *py_vuid;
2303         py_vuid = PyInt_FromLong(object->vuid);
2304         return py_vuid;
2305 }
2306
2307 static int py_dgram_smb_packet_set_vuid(PyObject *py_obj, PyObject *value, void *closure)
2308 {
2309         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(py_obj);
2310         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2311         object->vuid = PyInt_AsLong(value);
2312         return 0;
2313 }
2314
2315 static PyObject *py_dgram_smb_packet_get_mid(PyObject *obj, void *closure)
2316 {
2317         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(obj);
2318         PyObject *py_mid;
2319         py_mid = PyInt_FromLong(object->mid);
2320         return py_mid;
2321 }
2322
2323 static int py_dgram_smb_packet_set_mid(PyObject *py_obj, PyObject *value, void *closure)
2324 {
2325         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(py_obj);
2326         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2327         object->mid = PyInt_AsLong(value);
2328         return 0;
2329 }
2330
2331 static PyObject *py_dgram_smb_packet_get_body(PyObject *obj, void *closure)
2332 {
2333         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(obj);
2334         PyObject *py_body;
2335         py_body = py_import_smb_body(pytalloc_get_mem_ctx(obj), object->smb_command, &object->body);
2336         if (py_body == NULL) {
2337                 return NULL;
2338         }
2339         return py_body;
2340 }
2341
2342 static int py_dgram_smb_packet_set_body(PyObject *py_obj, PyObject *value, void *closure)
2343 {
2344         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(py_obj);
2345         {
2346                 union smb_body *body_switch_0;
2347                 body_switch_0 = py_export_smb_body(pytalloc_get_mem_ctx(py_obj), object->smb_command, value);
2348                 if (body_switch_0 == NULL) {
2349                         return -1;
2350                 }
2351                 object->body = *body_switch_0;
2352         }
2353         return 0;
2354 }
2355
2356 static PyGetSetDef py_dgram_smb_packet_getsetters[] = {
2357         { discard_const_p(char, "smb_command"), py_dgram_smb_packet_get_smb_command, py_dgram_smb_packet_set_smb_command },
2358         { discard_const_p(char, "err_class"), py_dgram_smb_packet_get_err_class, py_dgram_smb_packet_set_err_class },
2359         { discard_const_p(char, "pad"), py_dgram_smb_packet_get_pad, py_dgram_smb_packet_set_pad },
2360         { discard_const_p(char, "err_code"), py_dgram_smb_packet_get_err_code, py_dgram_smb_packet_set_err_code },
2361         { discard_const_p(char, "flags"), py_dgram_smb_packet_get_flags, py_dgram_smb_packet_set_flags },
2362         { discard_const_p(char, "flags2"), py_dgram_smb_packet_get_flags2, py_dgram_smb_packet_set_flags2 },
2363         { discard_const_p(char, "pid_high"), py_dgram_smb_packet_get_pid_high, py_dgram_smb_packet_set_pid_high },
2364         { discard_const_p(char, "signature"), py_dgram_smb_packet_get_signature, py_dgram_smb_packet_set_signature },
2365         { discard_const_p(char, "reserved"), py_dgram_smb_packet_get_reserved, py_dgram_smb_packet_set_reserved },
2366         { discard_const_p(char, "tid"), py_dgram_smb_packet_get_tid, py_dgram_smb_packet_set_tid },
2367         { discard_const_p(char, "pid"), py_dgram_smb_packet_get_pid, py_dgram_smb_packet_set_pid },
2368         { discard_const_p(char, "vuid"), py_dgram_smb_packet_get_vuid, py_dgram_smb_packet_set_vuid },
2369         { discard_const_p(char, "mid"), py_dgram_smb_packet_get_mid, py_dgram_smb_packet_set_mid },
2370         { discard_const_p(char, "body"), py_dgram_smb_packet_get_body, py_dgram_smb_packet_set_body },
2371         { NULL }
2372 };
2373
2374 static PyObject *py_dgram_smb_packet_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2375 {
2376         return pytalloc_new(struct dgram_smb_packet, type);
2377 }
2378
2379 static PyObject *py_dgram_smb_packet_ndr_pack(PyObject *py_obj)
2380 {
2381         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(py_obj);
2382         DATA_BLOB blob;
2383         enum ndr_err_code err;
2384         err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_dgram_smb_packet);
2385         if (err != NDR_ERR_SUCCESS) {
2386                 PyErr_SetNdrError(err);
2387                 return NULL;
2388         }
2389
2390         return PyString_FromStringAndSize((char *)blob.data, blob.length);
2391 }
2392
2393 static PyObject *py_dgram_smb_packet_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
2394 {
2395         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(py_obj);
2396         DATA_BLOB blob;
2397         int blob_length = 0;
2398         enum ndr_err_code err;
2399         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
2400         PyObject *allow_remaining_obj = NULL;
2401         bool allow_remaining = false;
2402
2403         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
2404                 discard_const_p(char *, kwnames),
2405                 &blob.data, &blob_length,
2406                 &allow_remaining_obj)) {
2407                 return NULL;
2408         }
2409         blob.length = blob_length;
2410
2411         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
2412                 allow_remaining = true;
2413         }
2414
2415         if (allow_remaining) {
2416                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_dgram_smb_packet);
2417         } else {
2418                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_dgram_smb_packet);
2419         }
2420         if (err != NDR_ERR_SUCCESS) {
2421                 PyErr_SetNdrError(err);
2422                 return NULL;
2423         }
2424
2425         Py_RETURN_NONE;
2426 }
2427
2428 static PyObject *py_dgram_smb_packet_ndr_print(PyObject *py_obj)
2429 {
2430         struct dgram_smb_packet *object = (struct dgram_smb_packet *)pytalloc_get_ptr(py_obj);
2431         PyObject *ret;
2432         char *retstr;
2433
2434         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_dgram_smb_packet, "dgram_smb_packet", object);
2435         ret = PyString_FromString(retstr);
2436         talloc_free(retstr);
2437
2438         return ret;
2439 }
2440
2441 static PyMethodDef py_dgram_smb_packet_methods[] = {
2442         { "__ndr_pack__", (PyCFunction)py_dgram_smb_packet_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
2443         { "__ndr_unpack__", (PyCFunction)py_dgram_smb_packet_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
2444         { "__ndr_print__", (PyCFunction)py_dgram_smb_packet_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
2445         { NULL, NULL, 0, NULL }
2446 };
2447
2448
2449 static PyTypeObject dgram_smb_packet_Type = {
2450         PyObject_HEAD_INIT(NULL) 0,
2451         .tp_name = "nbt.dgram_smb_packet",
2452         .tp_getset = py_dgram_smb_packet_getsetters,
2453         .tp_methods = py_dgram_smb_packet_methods,
2454         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2455         .tp_basicsize = sizeof(pytalloc_Object),
2456         .tp_new = py_dgram_smb_packet_new,
2457 };
2458
2459 PyObject *py_import_dgram_message_body(TALLOC_CTX *mem_ctx, int level, union dgram_message_body *in)
2460 {
2461         PyObject *ret;
2462
2463         switch (level) {
2464                 case DGRAM_SMB:
2465                         ret = pytalloc_reference_ex(&dgram_smb_packet_Type, mem_ctx, &in->smb);
2466                         return ret;
2467
2468         }
2469         PyErr_SetString(PyExc_TypeError, "unknown union level");
2470         return NULL;
2471 }
2472
2473 union dgram_message_body *py_export_dgram_message_body(TALLOC_CTX *mem_ctx, int level, PyObject *in)
2474 {
2475         union dgram_message_body *ret = talloc_zero(mem_ctx, union dgram_message_body);
2476         switch (level) {
2477                 case DGRAM_SMB:
2478                         PY_CHECK_TYPE(&dgram_smb_packet_Type, in, talloc_free(ret); return NULL;);
2479                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
2480                                 PyErr_NoMemory();
2481                                 talloc_free(ret); return NULL;
2482                         }
2483                         ret->smb = *(struct dgram_smb_packet *)pytalloc_get_ptr(in);
2484                         break;
2485
2486                 default:
2487                         PyErr_SetString(PyExc_TypeError, "invalid union level value");
2488                         talloc_free(ret);
2489                         ret = NULL;
2490         }
2491
2492         return ret;
2493 }
2494
2495
2496 static PyObject *py_dgram_message_get_length(PyObject *obj, void *closure)
2497 {
2498         struct dgram_message *object = (struct dgram_message *)pytalloc_get_ptr(obj);
2499         PyObject *py_length;
2500         py_length = PyInt_FromLong(object->length);
2501         return py_length;
2502 }
2503
2504 static int py_dgram_message_set_length(PyObject *py_obj, PyObject *value, void *closure)
2505 {
2506         struct dgram_message *object = (struct dgram_message *)pytalloc_get_ptr(py_obj);
2507         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2508         object->length = PyInt_AsLong(value);
2509         return 0;
2510 }
2511
2512 static PyObject *py_dgram_message_get_offset(PyObject *obj, void *closure)
2513 {
2514         struct dgram_message *object = (struct dgram_message *)pytalloc_get_ptr(obj);
2515         PyObject *py_offset;
2516         py_offset = PyInt_FromLong(object->offset);
2517         return py_offset;
2518 }
2519
2520 static int py_dgram_message_set_offset(PyObject *py_obj, PyObject *value, void *closure)
2521 {
2522         struct dgram_message *object = (struct dgram_message *)pytalloc_get_ptr(py_obj);
2523         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2524         object->offset = PyInt_AsLong(value);
2525         return 0;
2526 }
2527
2528 static PyObject *py_dgram_message_get_source_name(PyObject *obj, void *closure)
2529 {
2530         struct dgram_message *object = (struct dgram_message *)pytalloc_get_ptr(obj);
2531         PyObject *py_source_name;
2532         py_source_name = pytalloc_reference_ex(&nbt_name_Type, pytalloc_get_mem_ctx(obj), &object->source_name);
2533         return py_source_name;
2534 }
2535
2536 static int py_dgram_message_set_source_name(PyObject *py_obj, PyObject *value, void *closure)
2537 {
2538         struct dgram_message *object = (struct dgram_message *)pytalloc_get_ptr(py_obj);
2539         PY_CHECK_TYPE(&nbt_name_Type, value, return -1;);
2540         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
2541                 PyErr_NoMemory();
2542                 return -1;
2543         }
2544         object->source_name = *(struct nbt_name *)pytalloc_get_ptr(value);
2545         return 0;
2546 }
2547
2548 static PyObject *py_dgram_message_get_dest_name(PyObject *obj, void *closure)
2549 {
2550         struct dgram_message *object = (struct dgram_message *)pytalloc_get_ptr(obj);
2551         PyObject *py_dest_name;
2552         py_dest_name = pytalloc_reference_ex(&nbt_name_Type, pytalloc_get_mem_ctx(obj), &object->dest_name);
2553         return py_dest_name;
2554 }
2555
2556 static int py_dgram_message_set_dest_name(PyObject *py_obj, PyObject *value, void *closure)
2557 {
2558         struct dgram_message *object = (struct dgram_message *)pytalloc_get_ptr(py_obj);
2559         PY_CHECK_TYPE(&nbt_name_Type, value, return -1;);
2560         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
2561                 PyErr_NoMemory();
2562                 return -1;
2563         }
2564         object->dest_name = *(struct nbt_name *)pytalloc_get_ptr(value);
2565         return 0;
2566 }
2567
2568 static PyObject *py_dgram_message_get_dgram_body_type(PyObject *obj, void *closure)
2569 {
2570         struct dgram_message *object = (struct dgram_message *)pytalloc_get_ptr(obj);
2571         PyObject *py_dgram_body_type;
2572         py_dgram_body_type = PyInt_FromLong(object->dgram_body_type);
2573         return py_dgram_body_type;
2574 }
2575
2576 static int py_dgram_message_set_dgram_body_type(PyObject *py_obj, PyObject *value, void *closure)
2577 {
2578         struct dgram_message *object = (struct dgram_message *)pytalloc_get_ptr(py_obj);
2579         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2580         object->dgram_body_type = PyInt_AsLong(value);
2581         return 0;
2582 }
2583
2584 static PyObject *py_dgram_message_get_body(PyObject *obj, void *closure)
2585 {
2586         struct dgram_message *object = (struct dgram_message *)pytalloc_get_ptr(obj);
2587         PyObject *py_body;
2588         py_body = py_import_dgram_message_body(pytalloc_get_mem_ctx(obj), object->dgram_body_type, &object->body);
2589         if (py_body == NULL) {
2590                 return NULL;
2591         }
2592         return py_body;
2593 }
2594
2595 static int py_dgram_message_set_body(PyObject *py_obj, PyObject *value, void *closure)
2596 {
2597         struct dgram_message *object = (struct dgram_message *)pytalloc_get_ptr(py_obj);
2598         {
2599                 union dgram_message_body *body_switch_0;
2600                 body_switch_0 = py_export_dgram_message_body(pytalloc_get_mem_ctx(py_obj), object->dgram_body_type, value);
2601                 if (body_switch_0 == NULL) {
2602                         return -1;
2603                 }
2604                 object->body = *body_switch_0;
2605         }
2606         return 0;
2607 }
2608
2609 static PyGetSetDef py_dgram_message_getsetters[] = {
2610         { discard_const_p(char, "length"), py_dgram_message_get_length, py_dgram_message_set_length },
2611         { discard_const_p(char, "offset"), py_dgram_message_get_offset, py_dgram_message_set_offset },
2612         { discard_const_p(char, "source_name"), py_dgram_message_get_source_name, py_dgram_message_set_source_name },
2613         { discard_const_p(char, "dest_name"), py_dgram_message_get_dest_name, py_dgram_message_set_dest_name },
2614         { discard_const_p(char, "dgram_body_type"), py_dgram_message_get_dgram_body_type, py_dgram_message_set_dgram_body_type },
2615         { discard_const_p(char, "body"), py_dgram_message_get_body, py_dgram_message_set_body },
2616         { NULL }
2617 };
2618
2619 static PyObject *py_dgram_message_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2620 {
2621         return pytalloc_new(struct dgram_message, type);
2622 }
2623
2624
2625 static PyTypeObject dgram_message_Type = {
2626         PyObject_HEAD_INIT(NULL) 0,
2627         .tp_name = "nbt.dgram_message",
2628         .tp_getset = py_dgram_message_getsetters,
2629         .tp_methods = NULL,
2630         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2631         .tp_basicsize = sizeof(pytalloc_Object),
2632         .tp_new = py_dgram_message_new,
2633 };
2634
2635 PyObject *py_import_dgram_data(TALLOC_CTX *mem_ctx, int level, union dgram_data *in)
2636 {
2637         PyObject *ret;
2638
2639         switch (level) {
2640                 case DGRAM_DIRECT_UNIQUE:
2641                         ret = pytalloc_reference_ex(&dgram_message_Type, mem_ctx, &in->msg);
2642                         return ret;
2643
2644                 case DGRAM_DIRECT_GROUP:
2645                         ret = pytalloc_reference_ex(&dgram_message_Type, mem_ctx, &in->msg);
2646                         return ret;
2647
2648                 case DGRAM_BCAST:
2649                         ret = pytalloc_reference_ex(&dgram_message_Type, mem_ctx, &in->msg);
2650                         return ret;
2651
2652                 case DGRAM_ERROR:
2653                         ret = PyInt_FromLong(in->error);
2654                         return ret;
2655
2656                 case DGRAM_QUERY:
2657                         ret = pytalloc_reference_ex(&nbt_name_Type, mem_ctx, &in->dest_name);
2658                         return ret;
2659
2660                 case DGRAM_QUERY_POSITIVE:
2661                         ret = pytalloc_reference_ex(&nbt_name_Type, mem_ctx, &in->dest_name);
2662                         return ret;
2663
2664                 case DGRAM_QUERY_NEGATIVE:
2665                         ret = pytalloc_reference_ex(&nbt_name_Type, mem_ctx, &in->dest_name);
2666                         return ret;
2667
2668         }
2669         PyErr_SetString(PyExc_TypeError, "unknown union level");
2670         return NULL;
2671 }
2672
2673 union dgram_data *py_export_dgram_data(TALLOC_CTX *mem_ctx, int level, PyObject *in)
2674 {
2675         union dgram_data *ret = talloc_zero(mem_ctx, union dgram_data);
2676         switch (level) {
2677                 case DGRAM_DIRECT_UNIQUE:
2678                         PY_CHECK_TYPE(&dgram_message_Type, in, talloc_free(ret); return NULL;);
2679                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
2680                                 PyErr_NoMemory();
2681                                 talloc_free(ret); return NULL;
2682                         }
2683                         ret->msg = *(struct dgram_message *)pytalloc_get_ptr(in);
2684                         break;
2685
2686                 case DGRAM_DIRECT_GROUP:
2687                         PY_CHECK_TYPE(&dgram_message_Type, in, talloc_free(ret); return NULL;);
2688                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
2689                                 PyErr_NoMemory();
2690                                 talloc_free(ret); return NULL;
2691                         }
2692                         ret->msg = *(struct dgram_message *)pytalloc_get_ptr(in);
2693                         break;
2694
2695                 case DGRAM_BCAST:
2696                         PY_CHECK_TYPE(&dgram_message_Type, in, talloc_free(ret); return NULL;);
2697                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
2698                                 PyErr_NoMemory();
2699                                 talloc_free(ret); return NULL;
2700                         }
2701                         ret->msg = *(struct dgram_message *)pytalloc_get_ptr(in);
2702                         break;
2703
2704                 case DGRAM_ERROR:
2705                         if (PyLong_Check(in)) {
2706                                 ret->error = PyLong_AsLongLong(in);
2707                         } else if (PyInt_Check(in)) {
2708                                 ret->error = PyInt_AsLong(in);
2709                         } else {
2710                                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
2711                                   PyInt_Type.tp_name, PyLong_Type.tp_name);
2712                                 talloc_free(ret); return NULL;
2713                         }
2714                         break;
2715
2716                 case DGRAM_QUERY:
2717                         PY_CHECK_TYPE(&nbt_name_Type, in, talloc_free(ret); return NULL;);
2718                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
2719                                 PyErr_NoMemory();
2720                                 talloc_free(ret); return NULL;
2721                         }
2722                         ret->dest_name = *(struct nbt_name *)pytalloc_get_ptr(in);
2723                         break;
2724
2725                 case DGRAM_QUERY_POSITIVE:
2726                         PY_CHECK_TYPE(&nbt_name_Type, in, talloc_free(ret); return NULL;);
2727                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
2728                                 PyErr_NoMemory();
2729                                 talloc_free(ret); return NULL;
2730                         }
2731                         ret->dest_name = *(struct nbt_name *)pytalloc_get_ptr(in);
2732                         break;
2733
2734                 case DGRAM_QUERY_NEGATIVE:
2735                         PY_CHECK_TYPE(&nbt_name_Type, in, talloc_free(ret); return NULL;);
2736                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
2737                                 PyErr_NoMemory();
2738                                 talloc_free(ret); return NULL;
2739                         }
2740                         ret->dest_name = *(struct nbt_name *)pytalloc_get_ptr(in);
2741                         break;
2742
2743                 default:
2744                         PyErr_SetString(PyExc_TypeError, "invalid union level value");
2745                         talloc_free(ret);
2746                         ret = NULL;
2747         }
2748
2749         return ret;
2750 }
2751
2752
2753 static PyObject *py_nbt_dgram_packet_get_msg_type(PyObject *obj, void *closure)
2754 {
2755         struct nbt_dgram_packet *object = (struct nbt_dgram_packet *)pytalloc_get_ptr(obj);
2756         PyObject *py_msg_type;
2757         py_msg_type = PyInt_FromLong(object->msg_type);
2758         return py_msg_type;
2759 }
2760
2761 static int py_nbt_dgram_packet_set_msg_type(PyObject *py_obj, PyObject *value, void *closure)
2762 {
2763         struct nbt_dgram_packet *object = (struct nbt_dgram_packet *)pytalloc_get_ptr(py_obj);
2764         if (PyLong_Check(value)) {
2765                 object->msg_type = PyLong_AsLongLong(value);
2766         } else if (PyInt_Check(value)) {
2767                 object->msg_type = PyInt_AsLong(value);
2768         } else {
2769                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
2770                   PyInt_Type.tp_name, PyLong_Type.tp_name);
2771                 return -1;
2772         }
2773         return 0;
2774 }
2775
2776 static PyObject *py_nbt_dgram_packet_get_flags(PyObject *obj, void *closure)
2777 {
2778         struct nbt_dgram_packet *object = (struct nbt_dgram_packet *)pytalloc_get_ptr(obj);
2779         PyObject *py_flags;
2780         py_flags = PyInt_FromLong(object->flags);
2781         return py_flags;
2782 }
2783
2784 static int py_nbt_dgram_packet_set_flags(PyObject *py_obj, PyObject *value, void *closure)
2785 {
2786         struct nbt_dgram_packet *object = (struct nbt_dgram_packet *)pytalloc_get_ptr(py_obj);
2787         if (PyLong_Check(value)) {
2788                 object->flags = PyLong_AsLongLong(value);
2789         } else if (PyInt_Check(value)) {
2790                 object->flags = PyInt_AsLong(value);
2791         } else {
2792                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
2793                   PyInt_Type.tp_name, PyLong_Type.tp_name);
2794                 return -1;
2795         }
2796         return 0;
2797 }
2798
2799 static PyObject *py_nbt_dgram_packet_get_dgram_id(PyObject *obj, void *closure)
2800 {
2801         struct nbt_dgram_packet *object = (struct nbt_dgram_packet *)pytalloc_get_ptr(obj);
2802         PyObject *py_dgram_id;
2803         py_dgram_id = PyInt_FromLong(object->dgram_id);
2804         return py_dgram_id;
2805 }
2806
2807 static int py_nbt_dgram_packet_set_dgram_id(PyObject *py_obj, PyObject *value, void *closure)
2808 {
2809         struct nbt_dgram_packet *object = (struct nbt_dgram_packet *)pytalloc_get_ptr(py_obj);
2810         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2811         object->dgram_id = PyInt_AsLong(value);
2812         return 0;
2813 }
2814
2815 static PyObject *py_nbt_dgram_packet_get_src_addr(PyObject *obj, void *closure)
2816 {
2817         struct nbt_dgram_packet *object = (struct nbt_dgram_packet *)pytalloc_get_ptr(obj);
2818         PyObject *py_src_addr;
2819         py_src_addr = PyString_FromStringOrNULL(object->src_addr);
2820         return py_src_addr;
2821 }
2822
2823 static int py_nbt_dgram_packet_set_src_addr(PyObject *py_obj, PyObject *value, void *closure)
2824 {
2825         struct nbt_dgram_packet *object = (struct nbt_dgram_packet *)pytalloc_get_ptr(py_obj);
2826         object->src_addr = PyString_AS_STRING(value);
2827         return 0;
2828 }
2829
2830 static PyObject *py_nbt_dgram_packet_get_src_port(PyObject *obj, void *closure)
2831 {
2832         struct nbt_dgram_packet *object = (struct nbt_dgram_packet *)pytalloc_get_ptr(obj);
2833         PyObject *py_src_port;
2834         py_src_port = PyInt_FromLong(object->src_port);
2835         return py_src_port;
2836 }
2837
2838 static int py_nbt_dgram_packet_set_src_port(PyObject *py_obj, PyObject *value, void *closure)
2839 {
2840         struct nbt_dgram_packet *object = (struct nbt_dgram_packet *)pytalloc_get_ptr(py_obj);
2841         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2842         object->src_port = PyInt_AsLong(value);
2843         return 0;
2844 }
2845
2846 static PyObject *py_nbt_dgram_packet_get_data(PyObject *obj, void *closure)
2847 {
2848         struct nbt_dgram_packet *object = (struct nbt_dgram_packet *)pytalloc_get_ptr(obj);
2849         PyObject *py_data;
2850         py_data = py_import_dgram_data(pytalloc_get_mem_ctx(obj), object->msg_type, &object->data);
2851         if (py_data == NULL) {
2852                 return NULL;
2853         }
2854         return py_data;
2855 }
2856
2857 static int py_nbt_dgram_packet_set_data(PyObject *py_obj, PyObject *value, void *closure)
2858 {
2859         struct nbt_dgram_packet *object = (struct nbt_dgram_packet *)pytalloc_get_ptr(py_obj);
2860         {
2861                 union dgram_data *data_switch_0;
2862                 data_switch_0 = py_export_dgram_data(pytalloc_get_mem_ctx(py_obj), object->msg_type, value);
2863                 if (data_switch_0 == NULL) {
2864                         return -1;
2865                 }
2866                 object->data = *data_switch_0;
2867         }
2868         return 0;
2869 }
2870
2871 static PyGetSetDef py_nbt_dgram_packet_getsetters[] = {
2872         { discard_const_p(char, "msg_type"), py_nbt_dgram_packet_get_msg_type, py_nbt_dgram_packet_set_msg_type },
2873         { discard_const_p(char, "flags"), py_nbt_dgram_packet_get_flags, py_nbt_dgram_packet_set_flags },
2874         { discard_const_p(char, "dgram_id"), py_nbt_dgram_packet_get_dgram_id, py_nbt_dgram_packet_set_dgram_id },
2875         { discard_const_p(char, "src_addr"), py_nbt_dgram_packet_get_src_addr, py_nbt_dgram_packet_set_src_addr },
2876         { discard_const_p(char, "src_port"), py_nbt_dgram_packet_get_src_port, py_nbt_dgram_packet_set_src_port },
2877         { discard_const_p(char, "data"), py_nbt_dgram_packet_get_data, py_nbt_dgram_packet_set_data },
2878         { NULL }
2879 };
2880
2881 static PyObject *py_nbt_dgram_packet_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2882 {
2883         return pytalloc_new(struct nbt_dgram_packet, type);
2884 }
2885
2886 static PyObject *py_nbt_dgram_packet_ndr_pack(PyObject *py_obj)
2887 {
2888         struct nbt_dgram_packet *object = (struct nbt_dgram_packet *)pytalloc_get_ptr(py_obj);
2889         DATA_BLOB blob;
2890         enum ndr_err_code err;
2891         err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_nbt_dgram_packet);
2892         if (err != NDR_ERR_SUCCESS) {
2893                 PyErr_SetNdrError(err);
2894                 return NULL;
2895         }
2896
2897         return PyString_FromStringAndSize((char *)blob.data, blob.length);
2898 }
2899
2900 static PyObject *py_nbt_dgram_packet_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
2901 {
2902         struct nbt_dgram_packet *object = (struct nbt_dgram_packet *)pytalloc_get_ptr(py_obj);
2903         DATA_BLOB blob;
2904         int blob_length = 0;
2905         enum ndr_err_code err;
2906         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
2907         PyObject *allow_remaining_obj = NULL;
2908         bool allow_remaining = false;
2909
2910         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
2911                 discard_const_p(char *, kwnames),
2912                 &blob.data, &blob_length,
2913                 &allow_remaining_obj)) {
2914                 return NULL;
2915         }
2916         blob.length = blob_length;
2917
2918         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
2919                 allow_remaining = true;
2920         }
2921
2922         if (allow_remaining) {
2923                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_nbt_dgram_packet);
2924         } else {
2925                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_nbt_dgram_packet);
2926         }
2927         if (err != NDR_ERR_SUCCESS) {
2928                 PyErr_SetNdrError(err);
2929                 return NULL;
2930         }
2931
2932         Py_RETURN_NONE;
2933 }
2934
2935 static PyObject *py_nbt_dgram_packet_ndr_print(PyObject *py_obj)
2936 {
2937         struct nbt_dgram_packet *object = (struct nbt_dgram_packet *)pytalloc_get_ptr(py_obj);
2938         PyObject *ret;
2939         char *retstr;
2940
2941         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_nbt_dgram_packet, "nbt_dgram_packet", object);
2942         ret = PyString_FromString(retstr);
2943         talloc_free(retstr);
2944
2945         return ret;
2946 }
2947
2948 static PyMethodDef py_nbt_dgram_packet_methods[] = {
2949         { "__ndr_pack__", (PyCFunction)py_nbt_dgram_packet_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
2950         { "__ndr_unpack__", (PyCFunction)py_nbt_dgram_packet_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
2951         { "__ndr_print__", (PyCFunction)py_nbt_dgram_packet_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
2952         { NULL, NULL, 0, NULL }
2953 };
2954
2955
2956 static PyTypeObject nbt_dgram_packet_Type = {
2957         PyObject_HEAD_INIT(NULL) 0,
2958         .tp_name = "nbt.dgram_packet",
2959         .tp_getset = py_nbt_dgram_packet_getsetters,
2960         .tp_methods = py_nbt_dgram_packet_methods,
2961         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2962         .tp_basicsize = sizeof(pytalloc_Object),
2963         .tp_new = py_nbt_dgram_packet_new,
2964 };
2965
2966
2967 static PyObject *py_nbt_sockaddr_get_sockaddr_family(PyObject *obj, void *closure)
2968 {
2969         struct nbt_sockaddr *object = (struct nbt_sockaddr *)pytalloc_get_ptr(obj);
2970         PyObject *py_sockaddr_family;
2971         py_sockaddr_family = PyInt_FromLong(object->sockaddr_family);
2972         return py_sockaddr_family;
2973 }
2974
2975 static int py_nbt_sockaddr_set_sockaddr_family(PyObject *py_obj, PyObject *value, void *closure)
2976 {
2977         struct nbt_sockaddr *object = (struct nbt_sockaddr *)pytalloc_get_ptr(py_obj);
2978         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2979         object->sockaddr_family = PyInt_AsLong(value);
2980         return 0;
2981 }
2982
2983 static PyObject *py_nbt_sockaddr_get_pdc_ip(PyObject *obj, void *closure)
2984 {
2985         struct nbt_sockaddr *object = (struct nbt_sockaddr *)pytalloc_get_ptr(obj);
2986         PyObject *py_pdc_ip;
2987         py_pdc_ip = PyString_FromStringOrNULL(object->pdc_ip);
2988         return py_pdc_ip;
2989 }
2990
2991 static int py_nbt_sockaddr_set_pdc_ip(PyObject *py_obj, PyObject *value, void *closure)
2992 {
2993         struct nbt_sockaddr *object = (struct nbt_sockaddr *)pytalloc_get_ptr(py_obj);
2994         object->pdc_ip = PyString_AS_STRING(value);
2995         return 0;
2996 }
2997
2998 static PyObject *py_nbt_sockaddr_get_remaining(PyObject *obj, void *closure)
2999 {
3000         struct nbt_sockaddr *object = (struct nbt_sockaddr *)pytalloc_get_ptr(obj);
3001         PyObject *py_remaining;
3002         py_remaining = PyString_FromStringAndSize((char *)(object->remaining).data, (object->remaining).length);
3003         return py_remaining;
3004 }
3005
3006 static int py_nbt_sockaddr_set_remaining(PyObject *py_obj, PyObject *value, void *closure)
3007 {
3008         struct nbt_sockaddr *object = (struct nbt_sockaddr *)pytalloc_get_ptr(py_obj);
3009         object->remaining = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value), PyString_GET_SIZE(value));
3010         return 0;
3011 }
3012
3013 static PyGetSetDef py_nbt_sockaddr_getsetters[] = {
3014         { discard_const_p(char, "sockaddr_family"), py_nbt_sockaddr_get_sockaddr_family, py_nbt_sockaddr_set_sockaddr_family },
3015         { discard_const_p(char, "pdc_ip"), py_nbt_sockaddr_get_pdc_ip, py_nbt_sockaddr_set_pdc_ip },
3016         { discard_const_p(char, "remaining"), py_nbt_sockaddr_get_remaining, py_nbt_sockaddr_set_remaining },
3017         { NULL }
3018 };
3019
3020 static PyObject *py_nbt_sockaddr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3021 {
3022         return pytalloc_new(struct nbt_sockaddr, type);
3023 }
3024
3025 static PyObject *py_nbt_sockaddr_ndr_pack(PyObject *py_obj)
3026 {
3027         struct nbt_sockaddr *object = (struct nbt_sockaddr *)pytalloc_get_ptr(py_obj);
3028         DATA_BLOB blob;
3029         enum ndr_err_code err;
3030         err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_nbt_sockaddr);
3031         if (err != NDR_ERR_SUCCESS) {
3032                 PyErr_SetNdrError(err);
3033                 return NULL;
3034         }
3035
3036         return PyString_FromStringAndSize((char *)blob.data, blob.length);
3037 }
3038
3039 static PyObject *py_nbt_sockaddr_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
3040 {
3041         struct nbt_sockaddr *object = (struct nbt_sockaddr *)pytalloc_get_ptr(py_obj);
3042         DATA_BLOB blob;
3043         int blob_length = 0;
3044         enum ndr_err_code err;
3045         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
3046         PyObject *allow_remaining_obj = NULL;
3047         bool allow_remaining = false;
3048
3049         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
3050                 discard_const_p(char *, kwnames),
3051                 &blob.data, &blob_length,
3052                 &allow_remaining_obj)) {
3053                 return NULL;
3054         }
3055         blob.length = blob_length;
3056
3057         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
3058                 allow_remaining = true;
3059         }
3060
3061         if (allow_remaining) {
3062                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_nbt_sockaddr);
3063         } else {
3064                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_nbt_sockaddr);
3065         }
3066         if (err != NDR_ERR_SUCCESS) {
3067                 PyErr_SetNdrError(err);
3068                 return NULL;
3069         }
3070
3071         Py_RETURN_NONE;
3072 }
3073
3074 static PyObject *py_nbt_sockaddr_ndr_print(PyObject *py_obj)
3075 {
3076         struct nbt_sockaddr *object = (struct nbt_sockaddr *)pytalloc_get_ptr(py_obj);
3077         PyObject *ret;
3078         char *retstr;
3079
3080         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_nbt_sockaddr, "nbt_sockaddr", object);
3081         ret = PyString_FromString(retstr);
3082         talloc_free(retstr);
3083
3084         return ret;
3085 }
3086
3087 static PyMethodDef py_nbt_sockaddr_methods[] = {
3088         { "__ndr_pack__", (PyCFunction)py_nbt_sockaddr_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
3089         { "__ndr_unpack__", (PyCFunction)py_nbt_sockaddr_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
3090         { "__ndr_print__", (PyCFunction)py_nbt_sockaddr_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
3091         { NULL, NULL, 0, NULL }
3092 };
3093
3094
3095 static PyTypeObject nbt_sockaddr_Type = {
3096         PyObject_HEAD_INIT(NULL) 0,
3097         .tp_name = "nbt.sockaddr",
3098         .tp_getset = py_nbt_sockaddr_getsetters,
3099         .tp_methods = py_nbt_sockaddr_methods,
3100         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3101         .tp_basicsize = sizeof(pytalloc_Object),
3102         .tp_new = py_nbt_sockaddr_new,
3103 };
3104
3105
3106 static PyObject *py_NETLOGON_SAM_LOGON_REQUEST_get_request_count(PyObject *obj, void *closure)
3107 {
3108         struct NETLOGON_SAM_LOGON_REQUEST *object = (struct NETLOGON_SAM_LOGON_REQUEST *)pytalloc_get_ptr(obj);
3109         PyObject *py_request_count;
3110         py_request_count = PyInt_FromLong(object->request_count);
3111         return py_request_count;
3112 }
3113
3114 static int py_NETLOGON_SAM_LOGON_REQUEST_set_request_count(PyObject *py_obj, PyObject *value, void *closure)
3115 {
3116         struct NETLOGON_SAM_LOGON_REQUEST *object = (struct NETLOGON_SAM_LOGON_REQUEST *)pytalloc_get_ptr(py_obj);
3117         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3118         object->request_count = PyInt_AsLong(value);
3119         return 0;
3120 }
3121
3122 static PyObject *py_NETLOGON_SAM_LOGON_REQUEST_get_computer_name(PyObject *obj, void *closure)
3123 {
3124         struct NETLOGON_SAM_LOGON_REQUEST *object = (struct NETLOGON_SAM_LOGON_REQUEST *)pytalloc_get_ptr(obj);
3125         PyObject *py_computer_name;
3126         py_computer_name = PyString_FromStringOrNULL(object->computer_name);
3127         return py_computer_name;
3128 }
3129
3130 static int py_NETLOGON_SAM_LOGON_REQUEST_set_computer_name(PyObject *py_obj, PyObject *value, void *closure)
3131 {
3132         struct NETLOGON_SAM_LOGON_REQUEST *object = (struct NETLOGON_SAM_LOGON_REQUEST *)pytalloc_get_ptr(py_obj);
3133         object->computer_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
3134         return 0;
3135 }
3136
3137 static PyObject *py_NETLOGON_SAM_LOGON_REQUEST_get_user_name(PyObject *obj, void *closure)
3138 {
3139         struct NETLOGON_SAM_LOGON_REQUEST *object = (struct NETLOGON_SAM_LOGON_REQUEST *)pytalloc_get_ptr(obj);
3140         PyObject *py_user_name;
3141         py_user_name = PyString_FromStringOrNULL(object->user_name);
3142         return py_user_name;
3143 }
3144
3145 static int py_NETLOGON_SAM_LOGON_REQUEST_set_user_name(PyObject *py_obj, PyObject *value, void *closure)
3146 {
3147         struct NETLOGON_SAM_LOGON_REQUEST *object = (struct NETLOGON_SAM_LOGON_REQUEST *)pytalloc_get_ptr(py_obj);
3148         object->user_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
3149         return 0;
3150 }
3151
3152 static PyObject *py_NETLOGON_SAM_LOGON_REQUEST_get_mailslot_name(PyObject *obj, void *closure)
3153 {
3154         struct NETLOGON_SAM_LOGON_REQUEST *object = (struct NETLOGON_SAM_LOGON_REQUEST *)pytalloc_get_ptr(obj);
3155         PyObject *py_mailslot_name;
3156         py_mailslot_name = PyString_FromStringOrNULL(object->mailslot_name);
3157         return py_mailslot_name;
3158 }
3159
3160 static int py_NETLOGON_SAM_LOGON_REQUEST_set_mailslot_name(PyObject *py_obj, PyObject *value, void *closure)
3161 {
3162         struct NETLOGON_SAM_LOGON_REQUEST *object = (struct NETLOGON_SAM_LOGON_REQUEST *)pytalloc_get_ptr(py_obj);
3163         object->mailslot_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
3164         return 0;
3165 }
3166
3167 static PyObject *py_NETLOGON_SAM_LOGON_REQUEST_get_acct_control(PyObject *obj, void *closure)
3168 {
3169         struct NETLOGON_SAM_LOGON_REQUEST *object = (struct NETLOGON_SAM_LOGON_REQUEST *)pytalloc_get_ptr(obj);
3170         PyObject *py_acct_control;
3171         py_acct_control = PyInt_FromLong(object->acct_control);
3172         return py_acct_control;
3173 }
3174
3175 static int py_NETLOGON_SAM_LOGON_REQUEST_set_acct_control(PyObject *py_obj, PyObject *value, void *closure)
3176 {
3177         struct NETLOGON_SAM_LOGON_REQUEST *object = (struct NETLOGON_SAM_LOGON_REQUEST *)pytalloc_get_ptr(py_obj);
3178         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3179         object->acct_control = PyInt_AsLong(value);
3180         return 0;
3181 }
3182
3183 static PyObject *py_NETLOGON_SAM_LOGON_REQUEST_get_sid_size(PyObject *obj, void *closure)
3184 {
3185         struct NETLOGON_SAM_LOGON_REQUEST *object = (struct NETLOGON_SAM_LOGON_REQUEST *)pytalloc_get_ptr(obj);
3186         PyObject *py_sid_size;
3187         py_sid_size = PyInt_FromLong(object->sid_size);
3188         return py_sid_size;
3189 }
3190
3191 static int py_NETLOGON_SAM_LOGON_REQUEST_set_sid_size(PyObject *py_obj, PyObject *value, void *closure)
3192 {
3193         struct NETLOGON_SAM_LOGON_REQUEST *object = (struct NETLOGON_SAM_LOGON_REQUEST *)pytalloc_get_ptr(py_obj);
3194         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3195         object->sid_size = PyInt_AsLong(value);
3196         return 0;
3197 }
3198
3199 static PyObject *py_NETLOGON_SAM_LOGON_REQUEST_get__pad(PyObject *obj, void *closure)
3200 {
3201         struct NETLOGON_SAM_LOGON_REQUEST *object = (struct NETLOGON_SAM_LOGON_REQUEST *)pytalloc_get_ptr(obj);
3202         PyObject *py__pad;
3203         py__pad = PyString_FromStringAndSize((char *)(object->_pad).data, (object->_pad).length);
3204         return py__pad;
3205 }
3206
3207 static int py_NETLOGON_SAM_LOGON_REQUEST_set__pad(PyObject *py_obj, PyObject *value, void *closure)
3208 {
3209         struct NETLOGON_SAM_LOGON_REQUEST *object = (struct NETLOGON_SAM_LOGON_REQUEST *)pytalloc_get_ptr(py_obj);
3210         object->_pad = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value), PyString_GET_SIZE(value));
3211         return 0;
3212 }
3213
3214 static PyObject *py_NETLOGON_SAM_LOGON_REQUEST_get_sid(PyObject *obj, void *closure)
3215 {
3216         struct NETLOGON_SAM_LOGON_REQUEST *object = (struct NETLOGON_SAM_LOGON_REQUEST *)pytalloc_get_ptr(obj);
3217         PyObject *py_sid;
3218         py_sid = pytalloc_reference_ex(dom_sid_Type, pytalloc_get_mem_ctx(obj), &object->sid);
3219         return py_sid;
3220 }
3221
3222 static int py_NETLOGON_SAM_LOGON_REQUEST_set_sid(PyObject *py_obj, PyObject *value, void *closure)
3223 {
3224         struct NETLOGON_SAM_LOGON_REQUEST *object = (struct NETLOGON_SAM_LOGON_REQUEST *)pytalloc_get_ptr(py_obj);
3225         PY_CHECK_TYPE(dom_sid_Type, value, return -1;);
3226         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
3227                 PyErr_NoMemory();
3228                 return -1;
3229         }
3230         object->sid = *(struct dom_sid *)pytalloc_get_ptr(value);
3231         return 0;
3232 }
3233
3234 static PyObject *py_NETLOGON_SAM_LOGON_REQUEST_get_nt_version(PyObject *obj, void *closure)
3235 {
3236         struct NETLOGON_SAM_LOGON_REQUEST *object = (struct NETLOGON_SAM_LOGON_REQUEST *)pytalloc_get_ptr(obj);
3237         PyObject *py_nt_version;
3238         py_nt_version = PyInt_FromLong(object->nt_version);
3239         return py_nt_version;
3240 }
3241
3242 static int py_NETLOGON_SAM_LOGON_REQUEST_set_nt_version(PyObject *py_obj, PyObject *value, void *closure)
3243 {
3244         struct NETLOGON_SAM_LOGON_REQUEST *object = (struct NETLOGON_SAM_LOGON_REQUEST *)pytalloc_get_ptr(py_obj);
3245         if (PyLong_Check(value)) {
3246                 object->nt_version = PyLong_AsLongLong(value);
3247         } else if (PyInt_Check(value)) {
3248                 object->nt_version = PyInt_AsLong(value);
3249         } else {
3250                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
3251                   PyInt_Type.tp_name, PyLong_Type.tp_name);
3252                 return -1;
3253         }
3254         return 0;
3255 }
3256
3257 static PyObject *py_NETLOGON_SAM_LOGON_REQUEST_get_lmnt_token(PyObject *obj, void *closure)
3258 {
3259         struct NETLOGON_SAM_LOGON_REQUEST *object = (struct NETLOGON_SAM_LOGON_REQUEST *)pytalloc_get_ptr(obj);
3260         PyObject *py_lmnt_token;
3261         py_lmnt_token = PyInt_FromLong(object->lmnt_token);
3262         return py_lmnt_token;
3263 }
3264
3265 static int py_NETLOGON_SAM_LOGON_REQUEST_set_lmnt_token(PyObject *py_obj, PyObject *value, void *closure)
3266 {
3267         struct NETLOGON_SAM_LOGON_REQUEST *object = (struct NETLOGON_SAM_LOGON_REQUEST *)pytalloc_get_ptr(py_obj);
3268         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3269         object->lmnt_token = PyInt_AsLong(value);
3270         return 0;
3271 }
3272
3273 static PyObject *py_NETLOGON_SAM_LOGON_REQUEST_get_lm20_token(PyObject *obj, void *closure)
3274 {
3275         struct NETLOGON_SAM_LOGON_REQUEST *object = (struct NETLOGON_SAM_LOGON_REQUEST *)pytalloc_get_ptr(obj);
3276         PyObject *py_lm20_token;
3277         py_lm20_token = PyInt_FromLong(object->lm20_token);
3278         return py_lm20_token;
3279 }
3280
3281 static int py_NETLOGON_SAM_LOGON_REQUEST_set_lm20_token(PyObject *py_obj, PyObject *value, void *closure)
3282 {
3283         struct NETLOGON_SAM_LOGON_REQUEST *object = (struct NETLOGON_SAM_LOGON_REQUEST *)pytalloc_get_ptr(py_obj);
3284         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3285         object->lm20_token = PyInt_AsLong(value);
3286         return 0;
3287 }
3288
3289 static PyGetSetDef py_NETLOGON_SAM_LOGON_REQUEST_getsetters[] = {
3290         { discard_const_p(char, "request_count"), py_NETLOGON_SAM_LOGON_REQUEST_get_request_count, py_NETLOGON_SAM_LOGON_REQUEST_set_request_count },
3291         { discard_const_p(char, "computer_name"), py_NETLOGON_SAM_LOGON_REQUEST_get_computer_name, py_NETLOGON_SAM_LOGON_REQUEST_set_computer_name },
3292         { discard_const_p(char, "user_name"), py_NETLOGON_SAM_LOGON_REQUEST_get_user_name, py_NETLOGON_SAM_LOGON_REQUEST_set_user_name },
3293         { discard_const_p(char, "mailslot_name"), py_NETLOGON_SAM_LOGON_REQUEST_get_mailslot_name, py_NETLOGON_SAM_LOGON_REQUEST_set_mailslot_name },
3294         { discard_const_p(char, "acct_control"), py_NETLOGON_SAM_LOGON_REQUEST_get_acct_control, py_NETLOGON_SAM_LOGON_REQUEST_set_acct_control },
3295         { discard_const_p(char, "sid_size"), py_NETLOGON_SAM_LOGON_REQUEST_get_sid_size, py_NETLOGON_SAM_LOGON_REQUEST_set_sid_size },
3296         { discard_const_p(char, "_pad"), py_NETLOGON_SAM_LOGON_REQUEST_get__pad, py_NETLOGON_SAM_LOGON_REQUEST_set__pad },
3297         { discard_const_p(char, "sid"), py_NETLOGON_SAM_LOGON_REQUEST_get_sid, py_NETLOGON_SAM_LOGON_REQUEST_set_sid },
3298         { discard_const_p(char, "nt_version"), py_NETLOGON_SAM_LOGON_REQUEST_get_nt_version, py_NETLOGON_SAM_LOGON_REQUEST_set_nt_version },
3299         { discard_const_p(char, "lmnt_token"), py_NETLOGON_SAM_LOGON_REQUEST_get_lmnt_token, py_NETLOGON_SAM_LOGON_REQUEST_set_lmnt_token },
3300         { discard_const_p(char, "lm20_token"), py_NETLOGON_SAM_LOGON_REQUEST_get_lm20_token, py_NETLOGON_SAM_LOGON_REQUEST_set_lm20_token },
3301         { NULL }
3302 };
3303
3304 static PyObject *py_NETLOGON_SAM_LOGON_REQUEST_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3305 {
3306         return pytalloc_new(struct NETLOGON_SAM_LOGON_REQUEST, type);
3307 }
3308
3309
3310 static PyTypeObject NETLOGON_SAM_LOGON_REQUEST_Type = {
3311         PyObject_HEAD_INIT(NULL) 0,
3312         .tp_name = "nbt.NETLOGON_SAM_LOGON_REQUEST",
3313         .tp_getset = py_NETLOGON_SAM_LOGON_REQUEST_getsetters,
3314         .tp_methods = NULL,
3315         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3316         .tp_basicsize = sizeof(pytalloc_Object),
3317         .tp_new = py_NETLOGON_SAM_LOGON_REQUEST_new,
3318 };
3319
3320
3321 static PyObject *py_NETLOGON_LOGON_REQUEST_get_computer_name(PyObject *obj, void *closure)
3322 {
3323         struct NETLOGON_LOGON_REQUEST *object = (struct NETLOGON_LOGON_REQUEST *)pytalloc_get_ptr(obj);
3324         PyObject *py_computer_name;
3325         py_computer_name = PyString_FromStringOrNULL(object->computer_name);
3326         return py_computer_name;
3327 }
3328
3329 static int py_NETLOGON_LOGON_REQUEST_set_computer_name(PyObject *py_obj, PyObject *value, void *closure)
3330 {
3331         struct NETLOGON_LOGON_REQUEST *object = (struct NETLOGON_LOGON_REQUEST *)pytalloc_get_ptr(py_obj);
3332         object->computer_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
3333         return 0;
3334 }
3335
3336 static PyObject *py_NETLOGON_LOGON_REQUEST_get_user_name(PyObject *obj, void *closure)
3337 {
3338         struct NETLOGON_LOGON_REQUEST *object = (struct NETLOGON_LOGON_REQUEST *)pytalloc_get_ptr(obj);
3339         PyObject *py_user_name;
3340         py_user_name = PyString_FromStringOrNULL(object->user_name);
3341         return py_user_name;
3342 }
3343
3344 static int py_NETLOGON_LOGON_REQUEST_set_user_name(PyObject *py_obj, PyObject *value, void *closure)
3345 {
3346         struct NETLOGON_LOGON_REQUEST *object = (struct NETLOGON_LOGON_REQUEST *)pytalloc_get_ptr(py_obj);
3347         object->user_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
3348         return 0;
3349 }
3350
3351 static PyObject *py_NETLOGON_LOGON_REQUEST_get_mailslot_name(PyObject *obj, void *closure)
3352 {
3353         struct NETLOGON_LOGON_REQUEST *object = (struct NETLOGON_LOGON_REQUEST *)pytalloc_get_ptr(obj);
3354         PyObject *py_mailslot_name;
3355         py_mailslot_name = PyString_FromStringOrNULL(object->mailslot_name);
3356         return py_mailslot_name;
3357 }
3358
3359 static int py_NETLOGON_LOGON_REQUEST_set_mailslot_name(PyObject *py_obj, PyObject *value, void *closure)
3360 {
3361         struct NETLOGON_LOGON_REQUEST *object = (struct NETLOGON_LOGON_REQUEST *)pytalloc_get_ptr(py_obj);
3362         object->mailslot_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
3363         return 0;
3364 }
3365
3366 static PyObject *py_NETLOGON_LOGON_REQUEST_get_request_count(PyObject *obj, void *closure)
3367 {
3368         struct NETLOGON_LOGON_REQUEST *object = (struct NETLOGON_LOGON_REQUEST *)pytalloc_get_ptr(obj);
3369         PyObject *py_request_count;
3370         py_request_count = PyInt_FromLong(object->request_count);
3371         return py_request_count;
3372 }
3373
3374 static int py_NETLOGON_LOGON_REQUEST_set_request_count(PyObject *py_obj, PyObject *value, void *closure)
3375 {
3376         struct NETLOGON_LOGON_REQUEST *object = (struct NETLOGON_LOGON_REQUEST *)pytalloc_get_ptr(py_obj);
3377         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3378         object->request_count = PyInt_AsLong(value);
3379         return 0;
3380 }
3381
3382 static PyObject *py_NETLOGON_LOGON_REQUEST_get_lmnt_token(PyObject *obj, void *closure)
3383 {
3384         struct NETLOGON_LOGON_REQUEST *object = (struct NETLOGON_LOGON_REQUEST *)pytalloc_get_ptr(obj);
3385         PyObject *py_lmnt_token;
3386         py_lmnt_token = PyInt_FromLong(object->lmnt_token);
3387         return py_lmnt_token;
3388 }
3389
3390 static int py_NETLOGON_LOGON_REQUEST_set_lmnt_token(PyObject *py_obj, PyObject *value, void *closure)
3391 {
3392         struct NETLOGON_LOGON_REQUEST *object = (struct NETLOGON_LOGON_REQUEST *)pytalloc_get_ptr(py_obj);
3393         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3394         object->lmnt_token = PyInt_AsLong(value);
3395         return 0;
3396 }
3397
3398 static PyObject *py_NETLOGON_LOGON_REQUEST_get_lm20_token(PyObject *obj, void *closure)
3399 {
3400         struct NETLOGON_LOGON_REQUEST *object = (struct NETLOGON_LOGON_REQUEST *)pytalloc_get_ptr(obj);
3401         PyObject *py_lm20_token;
3402         py_lm20_token = PyInt_FromLong(object->lm20_token);
3403         return py_lm20_token;
3404 }
3405
3406 static int py_NETLOGON_LOGON_REQUEST_set_lm20_token(PyObject *py_obj, PyObject *value, void *closure)
3407 {
3408         struct NETLOGON_LOGON_REQUEST *object = (struct NETLOGON_LOGON_REQUEST *)pytalloc_get_ptr(py_obj);
3409         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3410         object->lm20_token = PyInt_AsLong(value);
3411         return 0;
3412 }
3413
3414 static PyGetSetDef py_NETLOGON_LOGON_REQUEST_getsetters[] = {
3415         { discard_const_p(char, "computer_name"), py_NETLOGON_LOGON_REQUEST_get_computer_name, py_NETLOGON_LOGON_REQUEST_set_computer_name },
3416         { discard_const_p(char, "user_name"), py_NETLOGON_LOGON_REQUEST_get_user_name, py_NETLOGON_LOGON_REQUEST_set_user_name },
3417         { discard_const_p(char, "mailslot_name"), py_NETLOGON_LOGON_REQUEST_get_mailslot_name, py_NETLOGON_LOGON_REQUEST_set_mailslot_name },
3418         { discard_const_p(char, "request_count"), py_NETLOGON_LOGON_REQUEST_get_request_count, py_NETLOGON_LOGON_REQUEST_set_request_count },
3419         { discard_const_p(char, "lmnt_token"), py_NETLOGON_LOGON_REQUEST_get_lmnt_token, py_NETLOGON_LOGON_REQUEST_set_lmnt_token },
3420         { discard_const_p(char, "lm20_token"), py_NETLOGON_LOGON_REQUEST_get_lm20_token, py_NETLOGON_LOGON_REQUEST_set_lm20_token },
3421         { NULL }
3422 };
3423
3424 static PyObject *py_NETLOGON_LOGON_REQUEST_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3425 {
3426         return pytalloc_new(struct NETLOGON_LOGON_REQUEST, type);
3427 }
3428
3429
3430 static PyTypeObject NETLOGON_LOGON_REQUEST_Type = {
3431         PyObject_HEAD_INIT(NULL) 0,
3432         .tp_name = "nbt.NETLOGON_LOGON_REQUEST",
3433         .tp_getset = py_NETLOGON_LOGON_REQUEST_getsetters,
3434         .tp_methods = NULL,
3435         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3436         .tp_basicsize = sizeof(pytalloc_Object),
3437         .tp_new = py_NETLOGON_LOGON_REQUEST_new,
3438 };
3439
3440
3441 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_NT40_get_command(PyObject *obj, void *closure)
3442 {
3443         struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *object = (struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *)pytalloc_get_ptr(obj);
3444         PyObject *py_command;
3445         py_command = PyInt_FromLong(object->command);
3446         return py_command;
3447 }
3448
3449 static int py_NETLOGON_SAM_LOGON_RESPONSE_NT40_set_command(PyObject *py_obj, PyObject *value, void *closure)
3450 {
3451         struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *object = (struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *)pytalloc_get_ptr(py_obj);
3452         if (PyLong_Check(value)) {
3453                 object->command = PyLong_AsLongLong(value);
3454         } else if (PyInt_Check(value)) {
3455                 object->command = PyInt_AsLong(value);
3456         } else {
3457                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
3458                   PyInt_Type.tp_name, PyLong_Type.tp_name);
3459                 return -1;
3460         }
3461         return 0;
3462 }
3463
3464 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_NT40_get_pdc_name(PyObject *obj, void *closure)
3465 {
3466         struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *object = (struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *)pytalloc_get_ptr(obj);
3467         PyObject *py_pdc_name;
3468         py_pdc_name = PyString_FromStringOrNULL(object->pdc_name);
3469         return py_pdc_name;
3470 }
3471
3472 static int py_NETLOGON_SAM_LOGON_RESPONSE_NT40_set_pdc_name(PyObject *py_obj, PyObject *value, void *closure)
3473 {
3474         struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *object = (struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *)pytalloc_get_ptr(py_obj);
3475         object->pdc_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
3476         return 0;
3477 }
3478
3479 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_NT40_get_user_name(PyObject *obj, void *closure)
3480 {
3481         struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *object = (struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *)pytalloc_get_ptr(obj);
3482         PyObject *py_user_name;
3483         py_user_name = PyString_FromStringOrNULL(object->user_name);
3484         return py_user_name;
3485 }
3486
3487 static int py_NETLOGON_SAM_LOGON_RESPONSE_NT40_set_user_name(PyObject *py_obj, PyObject *value, void *closure)
3488 {
3489         struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *object = (struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *)pytalloc_get_ptr(py_obj);
3490         object->user_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
3491         return 0;
3492 }
3493
3494 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_NT40_get_domain_name(PyObject *obj, void *closure)
3495 {
3496         struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *object = (struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *)pytalloc_get_ptr(obj);
3497         PyObject *py_domain_name;
3498         py_domain_name = PyString_FromStringOrNULL(object->domain_name);
3499         return py_domain_name;
3500 }
3501
3502 static int py_NETLOGON_SAM_LOGON_RESPONSE_NT40_set_domain_name(PyObject *py_obj, PyObject *value, void *closure)
3503 {
3504         struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *object = (struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *)pytalloc_get_ptr(py_obj);
3505         object->domain_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
3506         return 0;
3507 }
3508
3509 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_NT40_get_nt_version(PyObject *obj, void *closure)
3510 {
3511         struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *object = (struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *)pytalloc_get_ptr(obj);
3512         PyObject *py_nt_version;
3513         py_nt_version = PyInt_FromLong(object->nt_version);
3514         return py_nt_version;
3515 }
3516
3517 static int py_NETLOGON_SAM_LOGON_RESPONSE_NT40_set_nt_version(PyObject *py_obj, PyObject *value, void *closure)
3518 {
3519         struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *object = (struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *)pytalloc_get_ptr(py_obj);
3520         if (PyLong_Check(value)) {
3521                 object->nt_version = PyLong_AsLongLong(value);
3522         } else if (PyInt_Check(value)) {
3523                 object->nt_version = PyInt_AsLong(value);
3524         } else {
3525                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
3526                   PyInt_Type.tp_name, PyLong_Type.tp_name);
3527                 return -1;
3528         }
3529         return 0;
3530 }
3531
3532 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_NT40_get_lmnt_token(PyObject *obj, void *closure)
3533 {
3534         struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *object = (struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *)pytalloc_get_ptr(obj);
3535         PyObject *py_lmnt_token;
3536         py_lmnt_token = PyInt_FromLong(object->lmnt_token);
3537         return py_lmnt_token;
3538 }
3539
3540 static int py_NETLOGON_SAM_LOGON_RESPONSE_NT40_set_lmnt_token(PyObject *py_obj, PyObject *value, void *closure)
3541 {
3542         struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *object = (struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *)pytalloc_get_ptr(py_obj);
3543         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3544         object->lmnt_token = PyInt_AsLong(value);
3545         return 0;
3546 }
3547
3548 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_NT40_get_lm20_token(PyObject *obj, void *closure)
3549 {
3550         struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *object = (struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *)pytalloc_get_ptr(obj);
3551         PyObject *py_lm20_token;
3552         py_lm20_token = PyInt_FromLong(object->lm20_token);
3553         return py_lm20_token;
3554 }
3555
3556 static int py_NETLOGON_SAM_LOGON_RESPONSE_NT40_set_lm20_token(PyObject *py_obj, PyObject *value, void *closure)
3557 {
3558         struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *object = (struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *)pytalloc_get_ptr(py_obj);
3559         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3560         object->lm20_token = PyInt_AsLong(value);
3561         return 0;
3562 }
3563
3564 static PyGetSetDef py_NETLOGON_SAM_LOGON_RESPONSE_NT40_getsetters[] = {
3565         { discard_const_p(char, "command"), py_NETLOGON_SAM_LOGON_RESPONSE_NT40_get_command, py_NETLOGON_SAM_LOGON_RESPONSE_NT40_set_command },
3566         { discard_const_p(char, "pdc_name"), py_NETLOGON_SAM_LOGON_RESPONSE_NT40_get_pdc_name, py_NETLOGON_SAM_LOGON_RESPONSE_NT40_set_pdc_name },
3567         { discard_const_p(char, "user_name"), py_NETLOGON_SAM_LOGON_RESPONSE_NT40_get_user_name, py_NETLOGON_SAM_LOGON_RESPONSE_NT40_set_user_name },
3568         { discard_const_p(char, "domain_name"), py_NETLOGON_SAM_LOGON_RESPONSE_NT40_get_domain_name, py_NETLOGON_SAM_LOGON_RESPONSE_NT40_set_domain_name },
3569         { discard_const_p(char, "nt_version"), py_NETLOGON_SAM_LOGON_RESPONSE_NT40_get_nt_version, py_NETLOGON_SAM_LOGON_RESPONSE_NT40_set_nt_version },
3570         { discard_const_p(char, "lmnt_token"), py_NETLOGON_SAM_LOGON_RESPONSE_NT40_get_lmnt_token, py_NETLOGON_SAM_LOGON_RESPONSE_NT40_set_lmnt_token },
3571         { discard_const_p(char, "lm20_token"), py_NETLOGON_SAM_LOGON_RESPONSE_NT40_get_lm20_token, py_NETLOGON_SAM_LOGON_RESPONSE_NT40_set_lm20_token },
3572         { NULL }
3573 };
3574
3575 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_NT40_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3576 {
3577         return pytalloc_new(struct NETLOGON_SAM_LOGON_RESPONSE_NT40, type);
3578 }
3579
3580 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_NT40_ndr_pack(PyObject *py_obj)
3581 {
3582         struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *object = (struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *)pytalloc_get_ptr(py_obj);
3583         DATA_BLOB blob;
3584         enum ndr_err_code err;
3585         err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_NETLOGON_SAM_LOGON_RESPONSE_NT40);
3586         if (err != NDR_ERR_SUCCESS) {
3587                 PyErr_SetNdrError(err);
3588                 return NULL;
3589         }
3590
3591         return PyString_FromStringAndSize((char *)blob.data, blob.length);
3592 }
3593
3594 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_NT40_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
3595 {
3596         struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *object = (struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *)pytalloc_get_ptr(py_obj);
3597         DATA_BLOB blob;
3598         int blob_length = 0;
3599         enum ndr_err_code err;
3600         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
3601         PyObject *allow_remaining_obj = NULL;
3602         bool allow_remaining = false;
3603
3604         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
3605                 discard_const_p(char *, kwnames),
3606                 &blob.data, &blob_length,
3607                 &allow_remaining_obj)) {
3608                 return NULL;
3609         }
3610         blob.length = blob_length;
3611
3612         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
3613                 allow_remaining = true;
3614         }
3615
3616         if (allow_remaining) {
3617                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_NT40);
3618         } else {
3619                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_NT40);
3620         }
3621         if (err != NDR_ERR_SUCCESS) {
3622                 PyErr_SetNdrError(err);
3623                 return NULL;
3624         }
3625
3626         Py_RETURN_NONE;
3627 }
3628
3629 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_NT40_ndr_print(PyObject *py_obj)
3630 {
3631         struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *object = (struct NETLOGON_SAM_LOGON_RESPONSE_NT40 *)pytalloc_get_ptr(py_obj);
3632         PyObject *ret;
3633         char *retstr;
3634
3635         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_NETLOGON_SAM_LOGON_RESPONSE_NT40, "NETLOGON_SAM_LOGON_RESPONSE_NT40", object);
3636         ret = PyString_FromString(retstr);
3637         talloc_free(retstr);
3638
3639         return ret;
3640 }
3641
3642 static PyMethodDef py_NETLOGON_SAM_LOGON_RESPONSE_NT40_methods[] = {
3643         { "__ndr_pack__", (PyCFunction)py_NETLOGON_SAM_LOGON_RESPONSE_NT40_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
3644         { "__ndr_unpack__", (PyCFunction)py_NETLOGON_SAM_LOGON_RESPONSE_NT40_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
3645         { "__ndr_print__", (PyCFunction)py_NETLOGON_SAM_LOGON_RESPONSE_NT40_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
3646         { NULL, NULL, 0, NULL }
3647 };
3648
3649
3650 static PyTypeObject NETLOGON_SAM_LOGON_RESPONSE_NT40_Type = {
3651         PyObject_HEAD_INIT(NULL) 0,
3652         .tp_name = "nbt.NETLOGON_SAM_LOGON_RESPONSE_NT40",
3653         .tp_getset = py_NETLOGON_SAM_LOGON_RESPONSE_NT40_getsetters,
3654         .tp_methods = py_NETLOGON_SAM_LOGON_RESPONSE_NT40_methods,
3655         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
3656         .tp_basicsize = sizeof(pytalloc_Object),
3657         .tp_new = py_NETLOGON_SAM_LOGON_RESPONSE_NT40_new,
3658 };
3659
3660
3661 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_get_command(PyObject *obj, void *closure)
3662 {
3663         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(obj);
3664         PyObject *py_command;
3665         py_command = PyInt_FromLong(object->command);
3666         return py_command;
3667 }
3668
3669 static int py_NETLOGON_SAM_LOGON_RESPONSE_set_command(PyObject *py_obj, PyObject *value, void *closure)
3670 {
3671         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(py_obj);
3672         if (PyLong_Check(value)) {
3673                 object->command = PyLong_AsLongLong(value);
3674         } else if (PyInt_Check(value)) {
3675                 object->command = PyInt_AsLong(value);
3676         } else {
3677                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
3678                   PyInt_Type.tp_name, PyLong_Type.tp_name);
3679                 return -1;
3680         }
3681         return 0;
3682 }
3683
3684 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_get_pdc_name(PyObject *obj, void *closure)
3685 {
3686         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(obj);
3687         PyObject *py_pdc_name;
3688         py_pdc_name = PyString_FromStringOrNULL(object->pdc_name);
3689         return py_pdc_name;
3690 }
3691
3692 static int py_NETLOGON_SAM_LOGON_RESPONSE_set_pdc_name(PyObject *py_obj, PyObject *value, void *closure)
3693 {
3694         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(py_obj);
3695         object->pdc_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
3696         return 0;
3697 }
3698
3699 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_get_user_name(PyObject *obj, void *closure)
3700 {
3701         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(obj);
3702         PyObject *py_user_name;
3703         py_user_name = PyString_FromStringOrNULL(object->user_name);
3704         return py_user_name;
3705 }
3706
3707 static int py_NETLOGON_SAM_LOGON_RESPONSE_set_user_name(PyObject *py_obj, PyObject *value, void *closure)
3708 {
3709         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(py_obj);
3710         object->user_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
3711         return 0;
3712 }
3713
3714 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_get_domain_name(PyObject *obj, void *closure)
3715 {
3716         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(obj);
3717         PyObject *py_domain_name;
3718         py_domain_name = PyString_FromStringOrNULL(object->domain_name);
3719         return py_domain_name;
3720 }
3721
3722 static int py_NETLOGON_SAM_LOGON_RESPONSE_set_domain_name(PyObject *py_obj, PyObject *value, void *closure)
3723 {
3724         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(py_obj);
3725         object->domain_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
3726         return 0;
3727 }
3728
3729 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_get_domain_uuid(PyObject *obj, void *closure)
3730 {
3731         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(obj);
3732         PyObject *py_domain_uuid;
3733         py_domain_uuid = pytalloc_reference_ex(GUID_Type, pytalloc_get_mem_ctx(obj), &object->domain_uuid);
3734         return py_domain_uuid;
3735 }
3736
3737 static int py_NETLOGON_SAM_LOGON_RESPONSE_set_domain_uuid(PyObject *py_obj, PyObject *value, void *closure)
3738 {
3739         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(py_obj);
3740         PY_CHECK_TYPE(GUID_Type, value, return -1;);
3741         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
3742                 PyErr_NoMemory();
3743                 return -1;
3744         }
3745         object->domain_uuid = *(struct GUID *)pytalloc_get_ptr(value);
3746         return 0;
3747 }
3748
3749 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_get_zero_uuid(PyObject *obj, void *closure)
3750 {
3751         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(obj);
3752         PyObject *py_zero_uuid;
3753         py_zero_uuid = pytalloc_reference_ex(GUID_Type, pytalloc_get_mem_ctx(obj), &object->zero_uuid);
3754         return py_zero_uuid;
3755 }
3756
3757 static int py_NETLOGON_SAM_LOGON_RESPONSE_set_zero_uuid(PyObject *py_obj, PyObject *value, void *closure)
3758 {
3759         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(py_obj);
3760         PY_CHECK_TYPE(GUID_Type, value, return -1;);
3761         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
3762                 PyErr_NoMemory();
3763                 return -1;
3764         }
3765         object->zero_uuid = *(struct GUID *)pytalloc_get_ptr(value);
3766         return 0;
3767 }
3768
3769 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_get_forest(PyObject *obj, void *closure)
3770 {
3771         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(obj);
3772         PyObject *py_forest;
3773         py_forest = PyString_FromStringOrNULL(object->forest);
3774         return py_forest;
3775 }
3776
3777 static int py_NETLOGON_SAM_LOGON_RESPONSE_set_forest(PyObject *py_obj, PyObject *value, void *closure)
3778 {
3779         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(py_obj);
3780         object->forest = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
3781         return 0;
3782 }
3783
3784 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_get_dns_domain(PyObject *obj, void *closure)
3785 {
3786         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(obj);
3787         PyObject *py_dns_domain;
3788         py_dns_domain = PyString_FromStringOrNULL(object->dns_domain);
3789         return py_dns_domain;
3790 }
3791
3792 static int py_NETLOGON_SAM_LOGON_RESPONSE_set_dns_domain(PyObject *py_obj, PyObject *value, void *closure)
3793 {
3794         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(py_obj);
3795         object->dns_domain = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
3796         return 0;
3797 }
3798
3799 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_get_pdc_dns_name(PyObject *obj, void *closure)
3800 {
3801         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(obj);
3802         PyObject *py_pdc_dns_name;
3803         py_pdc_dns_name = PyString_FromStringOrNULL(object->pdc_dns_name);
3804         return py_pdc_dns_name;
3805 }
3806
3807 static int py_NETLOGON_SAM_LOGON_RESPONSE_set_pdc_dns_name(PyObject *py_obj, PyObject *value, void *closure)
3808 {
3809         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(py_obj);
3810         object->pdc_dns_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
3811         return 0;
3812 }
3813
3814 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_get_pdc_ip(PyObject *obj, void *closure)
3815 {
3816         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(obj);
3817         PyObject *py_pdc_ip;
3818         py_pdc_ip = PyString_FromStringOrNULL(object->pdc_ip);
3819         return py_pdc_ip;
3820 }
3821
3822 static int py_NETLOGON_SAM_LOGON_RESPONSE_set_pdc_ip(PyObject *py_obj, PyObject *value, void *closure)
3823 {
3824         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(py_obj);
3825         object->pdc_ip = PyString_AS_STRING(value);
3826         return 0;
3827 }
3828
3829 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_get_server_type(PyObject *obj, void *closure)
3830 {
3831         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(obj);
3832         PyObject *py_server_type;
3833         py_server_type = PyInt_FromLong(object->server_type);
3834         return py_server_type;
3835 }
3836
3837 static int py_NETLOGON_SAM_LOGON_RESPONSE_set_server_type(PyObject *py_obj, PyObject *value, void *closure)
3838 {
3839         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(py_obj);
3840         if (PyLong_Check(value)) {
3841                 object->server_type = PyLong_AsLongLong(value);
3842         } else if (PyInt_Check(value)) {
3843                 object->server_type = PyInt_AsLong(value);
3844         } else {
3845                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
3846                   PyInt_Type.tp_name, PyLong_Type.tp_name);
3847                 return -1;
3848         }
3849         return 0;
3850 }
3851
3852 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_get_nt_version(PyObject *obj, void *closure)
3853 {
3854         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(obj);
3855         PyObject *py_nt_version;
3856         py_nt_version = PyInt_FromLong(object->nt_version);
3857         return py_nt_version;
3858 }
3859
3860 static int py_NETLOGON_SAM_LOGON_RESPONSE_set_nt_version(PyObject *py_obj, PyObject *value, void *closure)
3861 {
3862         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(py_obj);
3863         if (PyLong_Check(value)) {
3864                 object->nt_version = PyLong_AsLongLong(value);
3865         } else if (PyInt_Check(value)) {
3866                 object->nt_version = PyInt_AsLong(value);
3867         } else {
3868                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
3869                   PyInt_Type.tp_name, PyLong_Type.tp_name);
3870                 return -1;
3871         }
3872         return 0;
3873 }
3874
3875 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_get_lmnt_token(PyObject *obj, void *closure)
3876 {
3877         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(obj);
3878         PyObject *py_lmnt_token;
3879         py_lmnt_token = PyInt_FromLong(object->lmnt_token);
3880         return py_lmnt_token;
3881 }
3882
3883 static int py_NETLOGON_SAM_LOGON_RESPONSE_set_lmnt_token(PyObject *py_obj, PyObject *value, void *closure)
3884 {
3885         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(py_obj);
3886         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3887         object->lmnt_token = PyInt_AsLong(value);
3888         return 0;
3889 }
3890
3891 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_get_lm20_token(PyObject *obj, void *closure)
3892 {
3893         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(obj);
3894         PyObject *py_lm20_token;
3895         py_lm20_token = PyInt_FromLong(object->lm20_token);
3896         return py_lm20_token;
3897 }
3898
3899 static int py_NETLOGON_SAM_LOGON_RESPONSE_set_lm20_token(PyObject *py_obj, PyObject *value, void *closure)
3900 {
3901         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(py_obj);
3902         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
3903         object->lm20_token = PyInt_AsLong(value);
3904         return 0;
3905 }
3906
3907 static PyGetSetDef py_NETLOGON_SAM_LOGON_RESPONSE_getsetters[] = {
3908         { discard_const_p(char, "command"), py_NETLOGON_SAM_LOGON_RESPONSE_get_command, py_NETLOGON_SAM_LOGON_RESPONSE_set_command },
3909         { discard_const_p(char, "pdc_name"), py_NETLOGON_SAM_LOGON_RESPONSE_get_pdc_name, py_NETLOGON_SAM_LOGON_RESPONSE_set_pdc_name },
3910         { discard_const_p(char, "user_name"), py_NETLOGON_SAM_LOGON_RESPONSE_get_user_name, py_NETLOGON_SAM_LOGON_RESPONSE_set_user_name },
3911         { discard_const_p(char, "domain_name"), py_NETLOGON_SAM_LOGON_RESPONSE_get_domain_name, py_NETLOGON_SAM_LOGON_RESPONSE_set_domain_name },
3912         { discard_const_p(char, "domain_uuid"), py_NETLOGON_SAM_LOGON_RESPONSE_get_domain_uuid, py_NETLOGON_SAM_LOGON_RESPONSE_set_domain_uuid },
3913         { discard_const_p(char, "zero_uuid"), py_NETLOGON_SAM_LOGON_RESPONSE_get_zero_uuid, py_NETLOGON_SAM_LOGON_RESPONSE_set_zero_uuid },
3914         { discard_const_p(char, "forest"), py_NETLOGON_SAM_LOGON_RESPONSE_get_forest, py_NETLOGON_SAM_LOGON_RESPONSE_set_forest },
3915         { discard_const_p(char, "dns_domain"), py_NETLOGON_SAM_LOGON_RESPONSE_get_dns_domain, py_NETLOGON_SAM_LOGON_RESPONSE_set_dns_domain },
3916         { discard_const_p(char, "pdc_dns_name"), py_NETLOGON_SAM_LOGON_RESPONSE_get_pdc_dns_name, py_NETLOGON_SAM_LOGON_RESPONSE_set_pdc_dns_name },
3917         { discard_const_p(char, "pdc_ip"), py_NETLOGON_SAM_LOGON_RESPONSE_get_pdc_ip, py_NETLOGON_SAM_LOGON_RESPONSE_set_pdc_ip },
3918         { discard_const_p(char, "server_type"), py_NETLOGON_SAM_LOGON_RESPONSE_get_server_type, py_NETLOGON_SAM_LOGON_RESPONSE_set_server_type },
3919         { discard_const_p(char, "nt_version"), py_NETLOGON_SAM_LOGON_RESPONSE_get_nt_version, py_NETLOGON_SAM_LOGON_RESPONSE_set_nt_version },
3920         { discard_const_p(char, "lmnt_token"), py_NETLOGON_SAM_LOGON_RESPONSE_get_lmnt_token, py_NETLOGON_SAM_LOGON_RESPONSE_set_lmnt_token },
3921         { discard_const_p(char, "lm20_token"), py_NETLOGON_SAM_LOGON_RESPONSE_get_lm20_token, py_NETLOGON_SAM_LOGON_RESPONSE_set_lm20_token },
3922         { NULL }
3923 };
3924
3925 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3926 {
3927         return pytalloc_new(struct NETLOGON_SAM_LOGON_RESPONSE, type);
3928 }
3929
3930 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_ndr_pack(PyObject *py_obj)
3931 {
3932         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(py_obj);
3933         DATA_BLOB blob;
3934         enum ndr_err_code err;
3935         err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_NETLOGON_SAM_LOGON_RESPONSE);
3936         if (err != NDR_ERR_SUCCESS) {
3937                 PyErr_SetNdrError(err);
3938                 return NULL;
3939         }
3940
3941         return PyString_FromStringAndSize((char *)blob.data, blob.length);
3942 }
3943
3944 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
3945 {
3946         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(py_obj);
3947         DATA_BLOB blob;
3948         int blob_length = 0;
3949         enum ndr_err_code err;
3950         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
3951         PyObject *allow_remaining_obj = NULL;
3952         bool allow_remaining = false;
3953
3954         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
3955                 discard_const_p(char *, kwnames),
3956                 &blob.data, &blob_length,
3957                 &allow_remaining_obj)) {
3958                 return NULL;
3959         }
3960         blob.length = blob_length;
3961
3962         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
3963                 allow_remaining = true;
3964         }
3965
3966         if (allow_remaining) {
3967                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_NETLOGON_SAM_LOGON_RESPONSE);
3968         } else {
3969                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_NETLOGON_SAM_LOGON_RESPONSE);
3970         }
3971         if (err != NDR_ERR_SUCCESS) {
3972                 PyErr_SetNdrError(err);
3973                 return NULL;
3974         }
3975
3976         Py_RETURN_NONE;
3977 }
3978
3979 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_ndr_print(PyObject *py_obj)
3980 {
3981         struct NETLOGON_SAM_LOGON_RESPONSE *object = (struct NETLOGON_SAM_LOGON_RESPONSE *)pytalloc_get_ptr(py_obj);
3982         PyObject *ret;
3983         char *retstr;
3984
3985         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_NETLOGON_SAM_LOGON_RESPONSE, "NETLOGON_SAM_LOGON_RESPONSE", object);
3986         ret = PyString_FromString(retstr);
3987         talloc_free(retstr);
3988
3989         return ret;
3990 }
3991
3992 static PyMethodDef py_NETLOGON_SAM_LOGON_RESPONSE_methods[] = {
3993         { "__ndr_pack__", (PyCFunction)py_NETLOGON_SAM_LOGON_RESPONSE_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
3994         { "__ndr_unpack__", (PyCFunction)py_NETLOGON_SAM_LOGON_RESPONSE_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
3995         { "__ndr_print__", (PyCFunction)py_NETLOGON_SAM_LOGON_RESPONSE_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
3996         { NULL, NULL, 0, NULL }
3997 };
3998
3999
4000 static PyTypeObject NETLOGON_SAM_LOGON_RESPONSE_Type = {
4001         PyObject_HEAD_INIT(NULL) 0,
4002         .tp_name = "nbt.NETLOGON_SAM_LOGON_RESPONSE",
4003         .tp_getset = py_NETLOGON_SAM_LOGON_RESPONSE_getsetters,
4004         .tp_methods = py_NETLOGON_SAM_LOGON_RESPONSE_methods,
4005         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4006         .tp_basicsize = sizeof(pytalloc_Object),
4007         .tp_new = py_NETLOGON_SAM_LOGON_RESPONSE_new,
4008 };
4009
4010
4011 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_command(PyObject *obj, void *closure)
4012 {
4013         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(obj);
4014         PyObject *py_command;
4015         py_command = PyInt_FromLong(object->command);
4016         return py_command;
4017 }
4018
4019 static int py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_command(PyObject *py_obj, PyObject *value, void *closure)
4020 {
4021         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(py_obj);
4022         if (PyLong_Check(value)) {
4023                 object->command = PyLong_AsLongLong(value);
4024         } else if (PyInt_Check(value)) {
4025                 object->command = PyInt_AsLong(value);
4026         } else {
4027                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
4028                   PyInt_Type.tp_name, PyLong_Type.tp_name);
4029                 return -1;
4030         }
4031         return 0;
4032 }
4033
4034 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_sbz(PyObject *obj, void *closure)
4035 {
4036         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(obj);
4037         PyObject *py_sbz;
4038         py_sbz = PyInt_FromLong(object->sbz);
4039         return py_sbz;
4040 }
4041
4042 static int py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_sbz(PyObject *py_obj, PyObject *value, void *closure)
4043 {
4044         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(py_obj);
4045         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4046         object->sbz = PyInt_AsLong(value);
4047         return 0;
4048 }
4049
4050 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_server_type(PyObject *obj, void *closure)
4051 {
4052         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(obj);
4053         PyObject *py_server_type;
4054         py_server_type = PyInt_FromLong(object->server_type);
4055         return py_server_type;
4056 }
4057
4058 static int py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_server_type(PyObject *py_obj, PyObject *value, void *closure)
4059 {
4060         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(py_obj);
4061         if (PyLong_Check(value)) {
4062                 object->server_type = PyLong_AsLongLong(value);
4063         } else if (PyInt_Check(value)) {
4064                 object->server_type = PyInt_AsLong(value);
4065         } else {
4066                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
4067                   PyInt_Type.tp_name, PyLong_Type.tp_name);
4068                 return -1;
4069         }
4070         return 0;
4071 }
4072
4073 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_domain_uuid(PyObject *obj, void *closure)
4074 {
4075         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(obj);
4076         PyObject *py_domain_uuid;
4077         py_domain_uuid = pytalloc_reference_ex(GUID_Type, pytalloc_get_mem_ctx(obj), &object->domain_uuid);
4078         return py_domain_uuid;
4079 }
4080
4081 static int py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_domain_uuid(PyObject *py_obj, PyObject *value, void *closure)
4082 {
4083         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(py_obj);
4084         PY_CHECK_TYPE(GUID_Type, value, return -1;);
4085         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
4086                 PyErr_NoMemory();
4087                 return -1;
4088         }
4089         object->domain_uuid = *(struct GUID *)pytalloc_get_ptr(value);
4090         return 0;
4091 }
4092
4093 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_forest(PyObject *obj, void *closure)
4094 {
4095         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(obj);
4096         PyObject *py_forest;
4097         py_forest = PyString_FromStringOrNULL(object->forest);
4098         return py_forest;
4099 }
4100
4101 static int py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_forest(PyObject *py_obj, PyObject *value, void *closure)
4102 {
4103         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(py_obj);
4104         object->forest = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
4105         return 0;
4106 }
4107
4108 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_dns_domain(PyObject *obj, void *closure)
4109 {
4110         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(obj);
4111         PyObject *py_dns_domain;
4112         py_dns_domain = PyString_FromStringOrNULL(object->dns_domain);
4113         return py_dns_domain;
4114 }
4115
4116 static int py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_dns_domain(PyObject *py_obj, PyObject *value, void *closure)
4117 {
4118         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(py_obj);
4119         object->dns_domain = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
4120         return 0;
4121 }
4122
4123 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_pdc_dns_name(PyObject *obj, void *closure)
4124 {
4125         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(obj);
4126         PyObject *py_pdc_dns_name;
4127         py_pdc_dns_name = PyString_FromStringOrNULL(object->pdc_dns_name);
4128         return py_pdc_dns_name;
4129 }
4130
4131 static int py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_pdc_dns_name(PyObject *py_obj, PyObject *value, void *closure)
4132 {
4133         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(py_obj);
4134         object->pdc_dns_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
4135         return 0;
4136 }
4137
4138 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_domain_name(PyObject *obj, void *closure)
4139 {
4140         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(obj);
4141         PyObject *py_domain_name;
4142         py_domain_name = PyString_FromStringOrNULL(object->domain_name);
4143         return py_domain_name;
4144 }
4145
4146 static int py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_domain_name(PyObject *py_obj, PyObject *value, void *closure)
4147 {
4148         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(py_obj);
4149         object->domain_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
4150         return 0;
4151 }
4152
4153 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_pdc_name(PyObject *obj, void *closure)
4154 {
4155         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(obj);
4156         PyObject *py_pdc_name;
4157         py_pdc_name = PyString_FromStringOrNULL(object->pdc_name);
4158         return py_pdc_name;
4159 }
4160
4161 static int py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_pdc_name(PyObject *py_obj, PyObject *value, void *closure)
4162 {
4163         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(py_obj);
4164         object->pdc_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
4165         return 0;
4166 }
4167
4168 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_user_name(PyObject *obj, void *closure)
4169 {
4170         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(obj);
4171         PyObject *py_user_name;
4172         py_user_name = PyString_FromStringOrNULL(object->user_name);
4173         return py_user_name;
4174 }
4175
4176 static int py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_user_name(PyObject *py_obj, PyObject *value, void *closure)
4177 {
4178         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(py_obj);
4179         object->user_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
4180         return 0;
4181 }
4182
4183 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_server_site(PyObject *obj, void *closure)
4184 {
4185         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(obj);
4186         PyObject *py_server_site;
4187         py_server_site = PyString_FromStringOrNULL(object->server_site);
4188         return py_server_site;
4189 }
4190
4191 static int py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_server_site(PyObject *py_obj, PyObject *value, void *closure)
4192 {
4193         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(py_obj);
4194         object->server_site = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
4195         return 0;
4196 }
4197
4198 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_client_site(PyObject *obj, void *closure)
4199 {
4200         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(obj);
4201         PyObject *py_client_site;
4202         py_client_site = PyString_FromStringOrNULL(object->client_site);
4203         return py_client_site;
4204 }
4205
4206 static int py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_client_site(PyObject *py_obj, PyObject *value, void *closure)
4207 {
4208         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(py_obj);
4209         object->client_site = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
4210         return 0;
4211 }
4212
4213 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_sockaddr_size(PyObject *obj, void *closure)
4214 {
4215         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(obj);
4216         PyObject *py_sockaddr_size;
4217         py_sockaddr_size = PyInt_FromLong(object->sockaddr_size);
4218         return py_sockaddr_size;
4219 }
4220
4221 static int py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_sockaddr_size(PyObject *py_obj, PyObject *value, void *closure)
4222 {
4223         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(py_obj);
4224         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4225         object->sockaddr_size = PyInt_AsLong(value);
4226         return 0;
4227 }
4228
4229 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_sockaddr(PyObject *obj, void *closure)
4230 {
4231         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(obj);
4232         PyObject *py_sockaddr;
4233         py_sockaddr = pytalloc_reference_ex(&nbt_sockaddr_Type, pytalloc_get_mem_ctx(obj), &object->sockaddr);
4234         return py_sockaddr;
4235 }
4236
4237 static int py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_sockaddr(PyObject *py_obj, PyObject *value, void *closure)
4238 {
4239         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(py_obj);
4240         PY_CHECK_TYPE(&nbt_sockaddr_Type, value, return -1;);
4241         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
4242                 PyErr_NoMemory();
4243                 return -1;
4244         }
4245         object->sockaddr = *(struct nbt_sockaddr *)pytalloc_get_ptr(value);
4246         return 0;
4247 }
4248
4249 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_next_closest_site(PyObject *obj, void *closure)
4250 {
4251         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(obj);
4252         PyObject *py_next_closest_site;
4253         py_next_closest_site = PyString_FromStringOrNULL(object->next_closest_site);
4254         return py_next_closest_site;
4255 }
4256
4257 static int py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_next_closest_site(PyObject *py_obj, PyObject *value, void *closure)
4258 {
4259         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(py_obj);
4260         object->next_closest_site = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
4261         return 0;
4262 }
4263
4264 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_nt_version(PyObject *obj, void *closure)
4265 {
4266         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(obj);
4267         PyObject *py_nt_version;
4268         py_nt_version = PyInt_FromLong(object->nt_version);
4269         return py_nt_version;
4270 }
4271
4272 static int py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_nt_version(PyObject *py_obj, PyObject *value, void *closure)
4273 {
4274         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(py_obj);
4275         if (PyLong_Check(value)) {
4276                 object->nt_version = PyLong_AsLongLong(value);
4277         } else if (PyInt_Check(value)) {
4278                 object->nt_version = PyInt_AsLong(value);
4279         } else {
4280                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
4281                   PyInt_Type.tp_name, PyLong_Type.tp_name);
4282                 return -1;
4283         }
4284         return 0;
4285 }
4286
4287 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_lmnt_token(PyObject *obj, void *closure)
4288 {
4289         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(obj);
4290         PyObject *py_lmnt_token;
4291         py_lmnt_token = PyInt_FromLong(object->lmnt_token);
4292         return py_lmnt_token;
4293 }
4294
4295 static int py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_lmnt_token(PyObject *py_obj, PyObject *value, void *closure)
4296 {
4297         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(py_obj);
4298         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4299         object->lmnt_token = PyInt_AsLong(value);
4300         return 0;
4301 }
4302
4303 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_lm20_token(PyObject *obj, void *closure)
4304 {
4305         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(obj);
4306         PyObject *py_lm20_token;
4307         py_lm20_token = PyInt_FromLong(object->lm20_token);
4308         return py_lm20_token;
4309 }
4310
4311 static int py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_lm20_token(PyObject *py_obj, PyObject *value, void *closure)
4312 {
4313         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(py_obj);
4314         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4315         object->lm20_token = PyInt_AsLong(value);
4316         return 0;
4317 }
4318
4319 static PyGetSetDef py_NETLOGON_SAM_LOGON_RESPONSE_EX_getsetters[] = {
4320         { discard_const_p(char, "command"), py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_command, py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_command },
4321         { discard_const_p(char, "sbz"), py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_sbz, py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_sbz },
4322         { discard_const_p(char, "server_type"), py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_server_type, py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_server_type },
4323         { discard_const_p(char, "domain_uuid"), py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_domain_uuid, py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_domain_uuid },
4324         { discard_const_p(char, "forest"), py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_forest, py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_forest },
4325         { discard_const_p(char, "dns_domain"), py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_dns_domain, py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_dns_domain },
4326         { discard_const_p(char, "pdc_dns_name"), py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_pdc_dns_name, py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_pdc_dns_name },
4327         { discard_const_p(char, "domain_name"), py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_domain_name, py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_domain_name },
4328         { discard_const_p(char, "pdc_name"), py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_pdc_name, py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_pdc_name },
4329         { discard_const_p(char, "user_name"), py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_user_name, py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_user_name },
4330         { discard_const_p(char, "server_site"), py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_server_site, py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_server_site },
4331         { discard_const_p(char, "client_site"), py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_client_site, py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_client_site },
4332         { discard_const_p(char, "sockaddr_size"), py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_sockaddr_size, py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_sockaddr_size },
4333         { discard_const_p(char, "sockaddr"), py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_sockaddr, py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_sockaddr },
4334         { discard_const_p(char, "next_closest_site"), py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_next_closest_site, py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_next_closest_site },
4335         { discard_const_p(char, "nt_version"), py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_nt_version, py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_nt_version },
4336         { discard_const_p(char, "lmnt_token"), py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_lmnt_token, py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_lmnt_token },
4337         { discard_const_p(char, "lm20_token"), py_NETLOGON_SAM_LOGON_RESPONSE_EX_get_lm20_token, py_NETLOGON_SAM_LOGON_RESPONSE_EX_set_lm20_token },
4338         { NULL }
4339 };
4340
4341 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_EX_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4342 {
4343         return pytalloc_new(struct NETLOGON_SAM_LOGON_RESPONSE_EX, type);
4344 }
4345
4346 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_EX_ndr_pack(PyObject *py_obj)
4347 {
4348         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(py_obj);
4349         DATA_BLOB blob;
4350         enum ndr_err_code err;
4351         err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_NETLOGON_SAM_LOGON_RESPONSE_EX);
4352         if (err != NDR_ERR_SUCCESS) {
4353                 PyErr_SetNdrError(err);
4354                 return NULL;
4355         }
4356
4357         return PyString_FromStringAndSize((char *)blob.data, blob.length);
4358 }
4359
4360 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_EX_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
4361 {
4362         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(py_obj);
4363         DATA_BLOB blob;
4364         int blob_length = 0;
4365         enum ndr_err_code err;
4366         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
4367         PyObject *allow_remaining_obj = NULL;
4368         bool allow_remaining = false;
4369
4370         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
4371                 discard_const_p(char *, kwnames),
4372                 &blob.data, &blob_length,
4373                 &allow_remaining_obj)) {
4374                 return NULL;
4375         }
4376         blob.length = blob_length;
4377
4378         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
4379                 allow_remaining = true;
4380         }
4381
4382         if (allow_remaining) {
4383                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_EX);
4384         } else {
4385                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_EX);
4386         }
4387         if (err != NDR_ERR_SUCCESS) {
4388                 PyErr_SetNdrError(err);
4389                 return NULL;
4390         }
4391
4392         Py_RETURN_NONE;
4393 }
4394
4395 static PyObject *py_NETLOGON_SAM_LOGON_RESPONSE_EX_ndr_print(PyObject *py_obj)
4396 {
4397         struct NETLOGON_SAM_LOGON_RESPONSE_EX *object = (struct NETLOGON_SAM_LOGON_RESPONSE_EX *)pytalloc_get_ptr(py_obj);
4398         PyObject *ret;
4399         char *retstr;
4400
4401         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_NETLOGON_SAM_LOGON_RESPONSE_EX, "NETLOGON_SAM_LOGON_RESPONSE_EX", object);
4402         ret = PyString_FromString(retstr);
4403         talloc_free(retstr);
4404
4405         return ret;
4406 }
4407
4408 static PyMethodDef py_NETLOGON_SAM_LOGON_RESPONSE_EX_methods[] = {
4409         { "__ndr_pack__", (PyCFunction)py_NETLOGON_SAM_LOGON_RESPONSE_EX_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
4410         { "__ndr_unpack__", (PyCFunction)py_NETLOGON_SAM_LOGON_RESPONSE_EX_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
4411         { "__ndr_print__", (PyCFunction)py_NETLOGON_SAM_LOGON_RESPONSE_EX_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
4412         { NULL, NULL, 0, NULL }
4413 };
4414
4415
4416 static PyTypeObject NETLOGON_SAM_LOGON_RESPONSE_EX_Type = {
4417         PyObject_HEAD_INIT(NULL) 0,
4418         .tp_name = "nbt.NETLOGON_SAM_LOGON_RESPONSE_EX",
4419         .tp_getset = py_NETLOGON_SAM_LOGON_RESPONSE_EX_getsetters,
4420         .tp_methods = py_NETLOGON_SAM_LOGON_RESPONSE_EX_methods,
4421         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4422         .tp_basicsize = sizeof(pytalloc_Object),
4423         .tp_new = py_NETLOGON_SAM_LOGON_RESPONSE_EX_new,
4424 };
4425
4426
4427 static PyObject *py_nbt_netlogon_query_for_pdc_get_computer_name(PyObject *obj, void *closure)
4428 {
4429         struct nbt_netlogon_query_for_pdc *object = (struct nbt_netlogon_query_for_pdc *)pytalloc_get_ptr(obj);
4430         PyObject *py_computer_name;
4431         py_computer_name = PyString_FromStringOrNULL(object->computer_name);
4432         return py_computer_name;
4433 }
4434
4435 static int py_nbt_netlogon_query_for_pdc_set_computer_name(PyObject *py_obj, PyObject *value, void *closure)
4436 {
4437         struct nbt_netlogon_query_for_pdc *object = (struct nbt_netlogon_query_for_pdc *)pytalloc_get_ptr(py_obj);
4438         object->computer_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
4439         return 0;
4440 }
4441
4442 static PyObject *py_nbt_netlogon_query_for_pdc_get_mailslot_name(PyObject *obj, void *closure)
4443 {
4444         struct nbt_netlogon_query_for_pdc *object = (struct nbt_netlogon_query_for_pdc *)pytalloc_get_ptr(obj);
4445         PyObject *py_mailslot_name;
4446         py_mailslot_name = PyString_FromStringOrNULL(object->mailslot_name);
4447         return py_mailslot_name;
4448 }
4449
4450 static int py_nbt_netlogon_query_for_pdc_set_mailslot_name(PyObject *py_obj, PyObject *value, void *closure)
4451 {
4452         struct nbt_netlogon_query_for_pdc *object = (struct nbt_netlogon_query_for_pdc *)pytalloc_get_ptr(py_obj);
4453         object->mailslot_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
4454         return 0;
4455 }
4456
4457 static PyObject *py_nbt_netlogon_query_for_pdc_get__pad(PyObject *obj, void *closure)
4458 {
4459         struct nbt_netlogon_query_for_pdc *object = (struct nbt_netlogon_query_for_pdc *)pytalloc_get_ptr(obj);
4460         PyObject *py__pad;
4461         py__pad = PyString_FromStringAndSize((char *)(object->_pad).data, (object->_pad).length);
4462         return py__pad;
4463 }
4464
4465 static int py_nbt_netlogon_query_for_pdc_set__pad(PyObject *py_obj, PyObject *value, void *closure)
4466 {
4467         struct nbt_netlogon_query_for_pdc *object = (struct nbt_netlogon_query_for_pdc *)pytalloc_get_ptr(py_obj);
4468         object->_pad = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value), PyString_GET_SIZE(value));
4469         return 0;
4470 }
4471
4472 static PyObject *py_nbt_netlogon_query_for_pdc_get_unicode_name(PyObject *obj, void *closure)
4473 {
4474         struct nbt_netlogon_query_for_pdc *object = (struct nbt_netlogon_query_for_pdc *)pytalloc_get_ptr(obj);
4475         PyObject *py_unicode_name;
4476         py_unicode_name = PyString_FromStringOrNULL(object->unicode_name);
4477         return py_unicode_name;
4478 }
4479
4480 static int py_nbt_netlogon_query_for_pdc_set_unicode_name(PyObject *py_obj, PyObject *value, void *closure)
4481 {
4482         struct nbt_netlogon_query_for_pdc *object = (struct nbt_netlogon_query_for_pdc *)pytalloc_get_ptr(py_obj);
4483         object->unicode_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
4484         return 0;
4485 }
4486
4487 static PyObject *py_nbt_netlogon_query_for_pdc_get_nt_version(PyObject *obj, void *closure)
4488 {
4489         struct nbt_netlogon_query_for_pdc *object = (struct nbt_netlogon_query_for_pdc *)pytalloc_get_ptr(obj);
4490         PyObject *py_nt_version;
4491         py_nt_version = PyInt_FromLong(object->nt_version);
4492         return py_nt_version;
4493 }
4494
4495 static int py_nbt_netlogon_query_for_pdc_set_nt_version(PyObject *py_obj, PyObject *value, void *closure)
4496 {
4497         struct nbt_netlogon_query_for_pdc *object = (struct nbt_netlogon_query_for_pdc *)pytalloc_get_ptr(py_obj);
4498         if (PyLong_Check(value)) {
4499                 object->nt_version = PyLong_AsLongLong(value);
4500         } else if (PyInt_Check(value)) {
4501                 object->nt_version = PyInt_AsLong(value);
4502         } else {
4503                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
4504                   PyInt_Type.tp_name, PyLong_Type.tp_name);
4505                 return -1;
4506         }
4507         return 0;
4508 }
4509
4510 static PyObject *py_nbt_netlogon_query_for_pdc_get_lmnt_token(PyObject *obj, void *closure)
4511 {
4512         struct nbt_netlogon_query_for_pdc *object = (struct nbt_netlogon_query_for_pdc *)pytalloc_get_ptr(obj);
4513         PyObject *py_lmnt_token;
4514         py_lmnt_token = PyInt_FromLong(object->lmnt_token);
4515         return py_lmnt_token;
4516 }
4517
4518 static int py_nbt_netlogon_query_for_pdc_set_lmnt_token(PyObject *py_obj, PyObject *value, void *closure)
4519 {
4520         struct nbt_netlogon_query_for_pdc *object = (struct nbt_netlogon_query_for_pdc *)pytalloc_get_ptr(py_obj);
4521         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4522         object->lmnt_token = PyInt_AsLong(value);
4523         return 0;
4524 }
4525
4526 static PyObject *py_nbt_netlogon_query_for_pdc_get_lm20_token(PyObject *obj, void *closure)
4527 {
4528         struct nbt_netlogon_query_for_pdc *object = (struct nbt_netlogon_query_for_pdc *)pytalloc_get_ptr(obj);
4529         PyObject *py_lm20_token;
4530         py_lm20_token = PyInt_FromLong(object->lm20_token);
4531         return py_lm20_token;
4532 }
4533
4534 static int py_nbt_netlogon_query_for_pdc_set_lm20_token(PyObject *py_obj, PyObject *value, void *closure)
4535 {
4536         struct nbt_netlogon_query_for_pdc *object = (struct nbt_netlogon_query_for_pdc *)pytalloc_get_ptr(py_obj);
4537         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4538         object->lm20_token = PyInt_AsLong(value);
4539         return 0;
4540 }
4541
4542 static PyGetSetDef py_nbt_netlogon_query_for_pdc_getsetters[] = {
4543         { discard_const_p(char, "computer_name"), py_nbt_netlogon_query_for_pdc_get_computer_name, py_nbt_netlogon_query_for_pdc_set_computer_name },
4544         { discard_const_p(char, "mailslot_name"), py_nbt_netlogon_query_for_pdc_get_mailslot_name, py_nbt_netlogon_query_for_pdc_set_mailslot_name },
4545         { discard_const_p(char, "_pad"), py_nbt_netlogon_query_for_pdc_get__pad, py_nbt_netlogon_query_for_pdc_set__pad },
4546         { discard_const_p(char, "unicode_name"), py_nbt_netlogon_query_for_pdc_get_unicode_name, py_nbt_netlogon_query_for_pdc_set_unicode_name },
4547         { discard_const_p(char, "nt_version"), py_nbt_netlogon_query_for_pdc_get_nt_version, py_nbt_netlogon_query_for_pdc_set_nt_version },
4548         { discard_const_p(char, "lmnt_token"), py_nbt_netlogon_query_for_pdc_get_lmnt_token, py_nbt_netlogon_query_for_pdc_set_lmnt_token },
4549         { discard_const_p(char, "lm20_token"), py_nbt_netlogon_query_for_pdc_get_lm20_token, py_nbt_netlogon_query_for_pdc_set_lm20_token },
4550         { NULL }
4551 };
4552
4553 static PyObject *py_nbt_netlogon_query_for_pdc_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4554 {
4555         return pytalloc_new(struct nbt_netlogon_query_for_pdc, type);
4556 }
4557
4558
4559 static PyTypeObject nbt_netlogon_query_for_pdc_Type = {
4560         PyObject_HEAD_INIT(NULL) 0,
4561         .tp_name = "nbt.netlogon_query_for_pdc",
4562         .tp_getset = py_nbt_netlogon_query_for_pdc_getsetters,
4563         .tp_methods = NULL,
4564         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4565         .tp_basicsize = sizeof(pytalloc_Object),
4566         .tp_new = py_nbt_netlogon_query_for_pdc_new,
4567 };
4568
4569
4570 static PyObject *py_nbt_netlogon_response_from_pdc_get_command(PyObject *obj, void *closure)
4571 {
4572         struct nbt_netlogon_response_from_pdc *object = (struct nbt_netlogon_response_from_pdc *)pytalloc_get_ptr(obj);
4573         PyObject *py_command;
4574         py_command = PyInt_FromLong(object->command);
4575         return py_command;
4576 }
4577
4578 static int py_nbt_netlogon_response_from_pdc_set_command(PyObject *py_obj, PyObject *value, void *closure)
4579 {
4580         struct nbt_netlogon_response_from_pdc *object = (struct nbt_netlogon_response_from_pdc *)pytalloc_get_ptr(py_obj);
4581         if (PyLong_Check(value)) {
4582                 object->command = PyLong_AsLongLong(value);
4583         } else if (PyInt_Check(value)) {
4584                 object->command = PyInt_AsLong(value);
4585         } else {
4586                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
4587                   PyInt_Type.tp_name, PyLong_Type.tp_name);
4588                 return -1;
4589         }
4590         return 0;
4591 }
4592
4593 static PyObject *py_nbt_netlogon_response_from_pdc_get_pdc_name(PyObject *obj, void *closure)
4594 {
4595         struct nbt_netlogon_response_from_pdc *object = (struct nbt_netlogon_response_from_pdc *)pytalloc_get_ptr(obj);
4596         PyObject *py_pdc_name;
4597         py_pdc_name = PyString_FromStringOrNULL(object->pdc_name);
4598         return py_pdc_name;
4599 }
4600
4601 static int py_nbt_netlogon_response_from_pdc_set_pdc_name(PyObject *py_obj, PyObject *value, void *closure)
4602 {
4603         struct nbt_netlogon_response_from_pdc *object = (struct nbt_netlogon_response_from_pdc *)pytalloc_get_ptr(py_obj);
4604         object->pdc_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
4605         return 0;
4606 }
4607
4608 static PyObject *py_nbt_netlogon_response_from_pdc_get__pad(PyObject *obj, void *closure)
4609 {
4610         struct nbt_netlogon_response_from_pdc *object = (struct nbt_netlogon_response_from_pdc *)pytalloc_get_ptr(obj);
4611         PyObject *py__pad;
4612         py__pad = PyString_FromStringAndSize((char *)(object->_pad).data, (object->_pad).length);
4613         return py__pad;
4614 }
4615
4616 static int py_nbt_netlogon_response_from_pdc_set__pad(PyObject *py_obj, PyObject *value, void *closure)
4617 {
4618         struct nbt_netlogon_response_from_pdc *object = (struct nbt_netlogon_response_from_pdc *)pytalloc_get_ptr(py_obj);
4619         object->_pad = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value), PyString_GET_SIZE(value));
4620         return 0;
4621 }
4622
4623 static PyObject *py_nbt_netlogon_response_from_pdc_get_unicode_pdc_name(PyObject *obj, void *closure)
4624 {
4625         struct nbt_netlogon_response_from_pdc *object = (struct nbt_netlogon_response_from_pdc *)pytalloc_get_ptr(obj);
4626         PyObject *py_unicode_pdc_name;
4627         py_unicode_pdc_name = PyString_FromStringOrNULL(object->unicode_pdc_name);
4628         return py_unicode_pdc_name;
4629 }
4630
4631 static int py_nbt_netlogon_response_from_pdc_set_unicode_pdc_name(PyObject *py_obj, PyObject *value, void *closure)
4632 {
4633         struct nbt_netlogon_response_from_pdc *object = (struct nbt_netlogon_response_from_pdc *)pytalloc_get_ptr(py_obj);
4634         object->unicode_pdc_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
4635         return 0;
4636 }
4637
4638 static PyObject *py_nbt_netlogon_response_from_pdc_get_domain_name(PyObject *obj, void *closure)
4639 {
4640         struct nbt_netlogon_response_from_pdc *object = (struct nbt_netlogon_response_from_pdc *)pytalloc_get_ptr(obj);
4641         PyObject *py_domain_name;
4642         py_domain_name = PyString_FromStringOrNULL(object->domain_name);
4643         return py_domain_name;
4644 }
4645
4646 static int py_nbt_netlogon_response_from_pdc_set_domain_name(PyObject *py_obj, PyObject *value, void *closure)
4647 {
4648         struct nbt_netlogon_response_from_pdc *object = (struct nbt_netlogon_response_from_pdc *)pytalloc_get_ptr(py_obj);
4649         object->domain_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
4650         return 0;
4651 }
4652
4653 static PyObject *py_nbt_netlogon_response_from_pdc_get_nt_version(PyObject *obj, void *closure)
4654 {
4655         struct nbt_netlogon_response_from_pdc *object = (struct nbt_netlogon_response_from_pdc *)pytalloc_get_ptr(obj);
4656         PyObject *py_nt_version;
4657         py_nt_version = PyInt_FromLong(object->nt_version);
4658         return py_nt_version;
4659 }
4660
4661 static int py_nbt_netlogon_response_from_pdc_set_nt_version(PyObject *py_obj, PyObject *value, void *closure)
4662 {
4663         struct nbt_netlogon_response_from_pdc *object = (struct nbt_netlogon_response_from_pdc *)pytalloc_get_ptr(py_obj);
4664         if (PyLong_Check(value)) {
4665                 object->nt_version = PyLong_AsLongLong(value);
4666         } else if (PyInt_Check(value)) {
4667                 object->nt_version = PyInt_AsLong(value);
4668         } else {
4669                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
4670                   PyInt_Type.tp_name, PyLong_Type.tp_name);
4671                 return -1;
4672         }
4673         return 0;
4674 }
4675
4676 static PyObject *py_nbt_netlogon_response_from_pdc_get_lmnt_token(PyObject *obj, void *closure)
4677 {
4678         struct nbt_netlogon_response_from_pdc *object = (struct nbt_netlogon_response_from_pdc *)pytalloc_get_ptr(obj);
4679         PyObject *py_lmnt_token;
4680         py_lmnt_token = PyInt_FromLong(object->lmnt_token);
4681         return py_lmnt_token;
4682 }
4683
4684 static int py_nbt_netlogon_response_from_pdc_set_lmnt_token(PyObject *py_obj, PyObject *value, void *closure)
4685 {
4686         struct nbt_netlogon_response_from_pdc *object = (struct nbt_netlogon_response_from_pdc *)pytalloc_get_ptr(py_obj);
4687         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4688         object->lmnt_token = PyInt_AsLong(value);
4689         return 0;
4690 }
4691
4692 static PyObject *py_nbt_netlogon_response_from_pdc_get_lm20_token(PyObject *obj, void *closure)
4693 {
4694         struct nbt_netlogon_response_from_pdc *object = (struct nbt_netlogon_response_from_pdc *)pytalloc_get_ptr(obj);
4695         PyObject *py_lm20_token;
4696         py_lm20_token = PyInt_FromLong(object->lm20_token);
4697         return py_lm20_token;
4698 }
4699
4700 static int py_nbt_netlogon_response_from_pdc_set_lm20_token(PyObject *py_obj, PyObject *value, void *closure)
4701 {
4702         struct nbt_netlogon_response_from_pdc *object = (struct nbt_netlogon_response_from_pdc *)pytalloc_get_ptr(py_obj);
4703         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4704         object->lm20_token = PyInt_AsLong(value);
4705         return 0;
4706 }
4707
4708 static PyGetSetDef py_nbt_netlogon_response_from_pdc_getsetters[] = {
4709         { discard_const_p(char, "command"), py_nbt_netlogon_response_from_pdc_get_command, py_nbt_netlogon_response_from_pdc_set_command },
4710         { discard_const_p(char, "pdc_name"), py_nbt_netlogon_response_from_pdc_get_pdc_name, py_nbt_netlogon_response_from_pdc_set_pdc_name },
4711         { discard_const_p(char, "_pad"), py_nbt_netlogon_response_from_pdc_get__pad, py_nbt_netlogon_response_from_pdc_set__pad },
4712         { discard_const_p(char, "unicode_pdc_name"), py_nbt_netlogon_response_from_pdc_get_unicode_pdc_name, py_nbt_netlogon_response_from_pdc_set_unicode_pdc_name },
4713         { discard_const_p(char, "domain_name"), py_nbt_netlogon_response_from_pdc_get_domain_name, py_nbt_netlogon_response_from_pdc_set_domain_name },
4714         { discard_const_p(char, "nt_version"), py_nbt_netlogon_response_from_pdc_get_nt_version, py_nbt_netlogon_response_from_pdc_set_nt_version },
4715         { discard_const_p(char, "lmnt_token"), py_nbt_netlogon_response_from_pdc_get_lmnt_token, py_nbt_netlogon_response_from_pdc_set_lmnt_token },
4716         { discard_const_p(char, "lm20_token"), py_nbt_netlogon_response_from_pdc_get_lm20_token, py_nbt_netlogon_response_from_pdc_set_lm20_token },
4717         { NULL }
4718 };
4719
4720 static PyObject *py_nbt_netlogon_response_from_pdc_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4721 {
4722         return pytalloc_new(struct nbt_netlogon_response_from_pdc, type);
4723 }
4724
4725 static PyObject *py_nbt_netlogon_response_from_pdc_ndr_pack(PyObject *py_obj)
4726 {
4727         struct nbt_netlogon_response_from_pdc *object = (struct nbt_netlogon_response_from_pdc *)pytalloc_get_ptr(py_obj);
4728         DATA_BLOB blob;
4729         enum ndr_err_code err;
4730         err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_nbt_netlogon_response_from_pdc);
4731         if (err != NDR_ERR_SUCCESS) {
4732                 PyErr_SetNdrError(err);
4733                 return NULL;
4734         }
4735
4736         return PyString_FromStringAndSize((char *)blob.data, blob.length);
4737 }
4738
4739 static PyObject *py_nbt_netlogon_response_from_pdc_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
4740 {
4741         struct nbt_netlogon_response_from_pdc *object = (struct nbt_netlogon_response_from_pdc *)pytalloc_get_ptr(py_obj);
4742         DATA_BLOB blob;
4743         int blob_length = 0;
4744         enum ndr_err_code err;
4745         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
4746         PyObject *allow_remaining_obj = NULL;
4747         bool allow_remaining = false;
4748
4749         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
4750                 discard_const_p(char *, kwnames),
4751                 &blob.data, &blob_length,
4752                 &allow_remaining_obj)) {
4753                 return NULL;
4754         }
4755         blob.length = blob_length;
4756
4757         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
4758                 allow_remaining = true;
4759         }
4760
4761         if (allow_remaining) {
4762                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_nbt_netlogon_response_from_pdc);
4763         } else {
4764                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_nbt_netlogon_response_from_pdc);
4765         }
4766         if (err != NDR_ERR_SUCCESS) {
4767                 PyErr_SetNdrError(err);
4768                 return NULL;
4769         }
4770
4771         Py_RETURN_NONE;
4772 }
4773
4774 static PyObject *py_nbt_netlogon_response_from_pdc_ndr_print(PyObject *py_obj)
4775 {
4776         struct nbt_netlogon_response_from_pdc *object = (struct nbt_netlogon_response_from_pdc *)pytalloc_get_ptr(py_obj);
4777         PyObject *ret;
4778         char *retstr;
4779
4780         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_nbt_netlogon_response_from_pdc, "nbt_netlogon_response_from_pdc", object);
4781         ret = PyString_FromString(retstr);
4782         talloc_free(retstr);
4783
4784         return ret;
4785 }
4786
4787 static PyMethodDef py_nbt_netlogon_response_from_pdc_methods[] = {
4788         { "__ndr_pack__", (PyCFunction)py_nbt_netlogon_response_from_pdc_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
4789         { "__ndr_unpack__", (PyCFunction)py_nbt_netlogon_response_from_pdc_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
4790         { "__ndr_print__", (PyCFunction)py_nbt_netlogon_response_from_pdc_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
4791         { NULL, NULL, 0, NULL }
4792 };
4793
4794
4795 static PyTypeObject nbt_netlogon_response_from_pdc_Type = {
4796         PyObject_HEAD_INIT(NULL) 0,
4797         .tp_name = "nbt.netlogon_response_from_pdc",
4798         .tp_getset = py_nbt_netlogon_response_from_pdc_getsetters,
4799         .tp_methods = py_nbt_netlogon_response_from_pdc_methods,
4800         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4801         .tp_basicsize = sizeof(pytalloc_Object),
4802         .tp_new = py_nbt_netlogon_response_from_pdc_new,
4803 };
4804
4805
4806 static PyObject *py_nbt_netlogon_response2_get_command(PyObject *obj, void *closure)
4807 {
4808         struct nbt_netlogon_response2 *object = (struct nbt_netlogon_response2 *)pytalloc_get_ptr(obj);
4809         PyObject *py_command;
4810         py_command = PyInt_FromLong(object->command);
4811         return py_command;
4812 }
4813
4814 static int py_nbt_netlogon_response2_set_command(PyObject *py_obj, PyObject *value, void *closure)
4815 {
4816         struct nbt_netlogon_response2 *object = (struct nbt_netlogon_response2 *)pytalloc_get_ptr(py_obj);
4817         if (PyLong_Check(value)) {
4818                 object->command = PyLong_AsLongLong(value);
4819         } else if (PyInt_Check(value)) {
4820                 object->command = PyInt_AsLong(value);
4821         } else {
4822                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
4823                   PyInt_Type.tp_name, PyLong_Type.tp_name);
4824                 return -1;
4825         }
4826         return 0;
4827 }
4828
4829 static PyObject *py_nbt_netlogon_response2_get_pdc_name(PyObject *obj, void *closure)
4830 {
4831         struct nbt_netlogon_response2 *object = (struct nbt_netlogon_response2 *)pytalloc_get_ptr(obj);
4832         PyObject *py_pdc_name;
4833         py_pdc_name = PyString_FromStringOrNULL(object->pdc_name);
4834         return py_pdc_name;
4835 }
4836
4837 static int py_nbt_netlogon_response2_set_pdc_name(PyObject *py_obj, PyObject *value, void *closure)
4838 {
4839         struct nbt_netlogon_response2 *object = (struct nbt_netlogon_response2 *)pytalloc_get_ptr(py_obj);
4840         object->pdc_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
4841         return 0;
4842 }
4843
4844 static PyObject *py_nbt_netlogon_response2_get_lm20_token(PyObject *obj, void *closure)
4845 {
4846         struct nbt_netlogon_response2 *object = (struct nbt_netlogon_response2 *)pytalloc_get_ptr(obj);
4847         PyObject *py_lm20_token;
4848         py_lm20_token = PyInt_FromLong(object->lm20_token);
4849         return py_lm20_token;
4850 }
4851
4852 static int py_nbt_netlogon_response2_set_lm20_token(PyObject *py_obj, PyObject *value, void *closure)
4853 {
4854         struct nbt_netlogon_response2 *object = (struct nbt_netlogon_response2 *)pytalloc_get_ptr(py_obj);
4855         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
4856         object->lm20_token = PyInt_AsLong(value);
4857         return 0;
4858 }
4859
4860 static PyGetSetDef py_nbt_netlogon_response2_getsetters[] = {
4861         { discard_const_p(char, "command"), py_nbt_netlogon_response2_get_command, py_nbt_netlogon_response2_set_command },
4862         { discard_const_p(char, "pdc_name"), py_nbt_netlogon_response2_get_pdc_name, py_nbt_netlogon_response2_set_pdc_name },
4863         { discard_const_p(char, "lm20_token"), py_nbt_netlogon_response2_get_lm20_token, py_nbt_netlogon_response2_set_lm20_token },
4864         { NULL }
4865 };
4866
4867 static PyObject *py_nbt_netlogon_response2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4868 {
4869         return pytalloc_new(struct nbt_netlogon_response2, type);
4870 }
4871
4872 static PyObject *py_nbt_netlogon_response2_ndr_pack(PyObject *py_obj)
4873 {
4874         struct nbt_netlogon_response2 *object = (struct nbt_netlogon_response2 *)pytalloc_get_ptr(py_obj);
4875         DATA_BLOB blob;
4876         enum ndr_err_code err;
4877         err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_nbt_netlogon_response2);
4878         if (err != NDR_ERR_SUCCESS) {
4879                 PyErr_SetNdrError(err);
4880                 return NULL;
4881         }
4882
4883         return PyString_FromStringAndSize((char *)blob.data, blob.length);
4884 }
4885
4886 static PyObject *py_nbt_netlogon_response2_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
4887 {
4888         struct nbt_netlogon_response2 *object = (struct nbt_netlogon_response2 *)pytalloc_get_ptr(py_obj);
4889         DATA_BLOB blob;
4890         int blob_length = 0;
4891         enum ndr_err_code err;
4892         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
4893         PyObject *allow_remaining_obj = NULL;
4894         bool allow_remaining = false;
4895
4896         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
4897                 discard_const_p(char *, kwnames),
4898                 &blob.data, &blob_length,
4899                 &allow_remaining_obj)) {
4900                 return NULL;
4901         }
4902         blob.length = blob_length;
4903
4904         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
4905                 allow_remaining = true;
4906         }
4907
4908         if (allow_remaining) {
4909                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_nbt_netlogon_response2);
4910         } else {
4911                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_nbt_netlogon_response2);
4912         }
4913         if (err != NDR_ERR_SUCCESS) {
4914                 PyErr_SetNdrError(err);
4915                 return NULL;
4916         }
4917
4918         Py_RETURN_NONE;
4919 }
4920
4921 static PyObject *py_nbt_netlogon_response2_ndr_print(PyObject *py_obj)
4922 {
4923         struct nbt_netlogon_response2 *object = (struct nbt_netlogon_response2 *)pytalloc_get_ptr(py_obj);
4924         PyObject *ret;
4925         char *retstr;
4926
4927         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_nbt_netlogon_response2, "nbt_netlogon_response2", object);
4928         ret = PyString_FromString(retstr);
4929         talloc_free(retstr);
4930
4931         return ret;
4932 }
4933
4934 static PyMethodDef py_nbt_netlogon_response2_methods[] = {
4935         { "__ndr_pack__", (PyCFunction)py_nbt_netlogon_response2_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
4936         { "__ndr_unpack__", (PyCFunction)py_nbt_netlogon_response2_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
4937         { "__ndr_print__", (PyCFunction)py_nbt_netlogon_response2_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
4938         { NULL, NULL, 0, NULL }
4939 };
4940
4941
4942 static PyTypeObject nbt_netlogon_response2_Type = {
4943         PyObject_HEAD_INIT(NULL) 0,
4944         .tp_name = "nbt.netlogon_response2",
4945         .tp_getset = py_nbt_netlogon_response2_getsetters,
4946         .tp_methods = py_nbt_netlogon_response2_methods,
4947         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
4948         .tp_basicsize = sizeof(pytalloc_Object),
4949         .tp_new = py_nbt_netlogon_response2_new,
4950 };
4951
4952
4953 static PyObject *py_nbt_db_change_info_get_db_index(PyObject *obj, void *closure)
4954 {
4955         struct nbt_db_change_info *object = (struct nbt_db_change_info *)pytalloc_get_ptr(obj);
4956         PyObject *py_db_index;
4957         py_db_index = PyInt_FromLong(object->db_index);
4958         return py_db_index;
4959 }
4960
4961 static int py_nbt_db_change_info_set_db_index(PyObject *py_obj, PyObject *value, void *closure)
4962 {
4963         struct nbt_db_change_info *object = (struct nbt_db_change_info *)pytalloc_get_ptr(py_obj);
4964         if (PyLong_Check(value)) {
4965                 object->db_index = PyLong_AsLongLong(value);
4966         } else if (PyInt_Check(value)) {
4967                 object->db_index = PyInt_AsLong(value);
4968         } else {
4969                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
4970                   PyInt_Type.tp_name, PyLong_Type.tp_name);
4971                 return -1;
4972         }
4973         return 0;
4974 }
4975
4976 static PyObject *py_nbt_db_change_info_get_serial(PyObject *obj, void *closure)
4977 {
4978         struct nbt_db_change_info *object = (struct nbt_db_change_info *)pytalloc_get_ptr(obj);
4979         PyObject *py_serial;
4980         py_serial = PyLong_FromLongLong(object->serial);
4981         return py_serial;
4982 }
4983
4984 static int py_nbt_db_change_info_set_serial(PyObject *py_obj, PyObject *value, void *closure)
4985 {
4986         struct nbt_db_change_info *object = (struct nbt_db_change_info *)pytalloc_get_ptr(py_obj);
4987         if (PyLong_Check(value)) {
4988                 object->serial = PyLong_AsLongLong(value);
4989         } else if (PyInt_Check(value)) {
4990                 object->serial = PyInt_AsLong(value);
4991         } else {
4992                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
4993                   PyInt_Type.tp_name, PyLong_Type.tp_name);
4994                 return -1;
4995         }
4996         return 0;
4997 }
4998
4999 static PyObject *py_nbt_db_change_info_get_timestamp(PyObject *obj, void *closure)
5000 {
5001         struct nbt_db_change_info *object = (struct nbt_db_change_info *)pytalloc_get_ptr(obj);
5002         PyObject *py_timestamp;
5003         py_timestamp = PyLong_FromLongLong(object->timestamp);
5004         return py_timestamp;
5005 }
5006
5007 static int py_nbt_db_change_info_set_timestamp(PyObject *py_obj, PyObject *value, void *closure)
5008 {
5009         struct nbt_db_change_info *object = (struct nbt_db_change_info *)pytalloc_get_ptr(py_obj);
5010         if (PyLong_Check(value)) {
5011                 object->timestamp = PyLong_AsLongLong(value);
5012         } else if (PyInt_Check(value)) {
5013                 object->timestamp = PyInt_AsLong(value);
5014         } else {
5015                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
5016                   PyInt_Type.tp_name, PyLong_Type.tp_name);
5017                 return -1;
5018         }
5019         return 0;
5020 }
5021
5022 static PyGetSetDef py_nbt_db_change_info_getsetters[] = {
5023         { discard_const_p(char, "db_index"), py_nbt_db_change_info_get_db_index, py_nbt_db_change_info_set_db_index },
5024         { discard_const_p(char, "serial"), py_nbt_db_change_info_get_serial, py_nbt_db_change_info_set_serial },
5025         { discard_const_p(char, "timestamp"), py_nbt_db_change_info_get_timestamp, py_nbt_db_change_info_set_timestamp },
5026         { NULL }
5027 };
5028
5029 static PyObject *py_nbt_db_change_info_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5030 {
5031         return pytalloc_new(struct nbt_db_change_info, type);
5032 }
5033
5034
5035 static PyTypeObject nbt_db_change_info_Type = {
5036         PyObject_HEAD_INIT(NULL) 0,
5037         .tp_name = "nbt.db_change_info",
5038         .tp_getset = py_nbt_db_change_info_getsetters,
5039         .tp_methods = NULL,
5040         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5041         .tp_basicsize = sizeof(pytalloc_Object),
5042         .tp_new = py_nbt_db_change_info_new,
5043 };
5044
5045
5046 static PyObject *py_NETLOGON_DB_CHANGE_get_serial_lo(PyObject *obj, void *closure)
5047 {
5048         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(obj);
5049         PyObject *py_serial_lo;
5050         py_serial_lo = PyInt_FromLong(object->serial_lo);
5051         return py_serial_lo;
5052 }
5053
5054 static int py_NETLOGON_DB_CHANGE_set_serial_lo(PyObject *py_obj, PyObject *value, void *closure)
5055 {
5056         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(py_obj);
5057         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5058         object->serial_lo = PyInt_AsLong(value);
5059         return 0;
5060 }
5061
5062 static PyObject *py_NETLOGON_DB_CHANGE_get_timestamp(PyObject *obj, void *closure)
5063 {
5064         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(obj);
5065         PyObject *py_timestamp;
5066         py_timestamp = PyInt_FromLong(object->timestamp);
5067         return py_timestamp;
5068 }
5069
5070 static int py_NETLOGON_DB_CHANGE_set_timestamp(PyObject *py_obj, PyObject *value, void *closure)
5071 {
5072         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(py_obj);
5073         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5074         object->timestamp = PyInt_AsLong(value);
5075         return 0;
5076 }
5077
5078 static PyObject *py_NETLOGON_DB_CHANGE_get_pulse(PyObject *obj, void *closure)
5079 {
5080         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(obj);
5081         PyObject *py_pulse;
5082         py_pulse = PyInt_FromLong(object->pulse);
5083         return py_pulse;
5084 }
5085
5086 static int py_NETLOGON_DB_CHANGE_set_pulse(PyObject *py_obj, PyObject *value, void *closure)
5087 {
5088         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(py_obj);
5089         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5090         object->pulse = PyInt_AsLong(value);
5091         return 0;
5092 }
5093
5094 static PyObject *py_NETLOGON_DB_CHANGE_get_random(PyObject *obj, void *closure)
5095 {
5096         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(obj);
5097         PyObject *py_random;
5098         py_random = PyInt_FromLong(object->random);
5099         return py_random;
5100 }
5101
5102 static int py_NETLOGON_DB_CHANGE_set_random(PyObject *py_obj, PyObject *value, void *closure)
5103 {
5104         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(py_obj);
5105         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5106         object->random = PyInt_AsLong(value);
5107         return 0;
5108 }
5109
5110 static PyObject *py_NETLOGON_DB_CHANGE_get_pdc_name(PyObject *obj, void *closure)
5111 {
5112         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(obj);
5113         PyObject *py_pdc_name;
5114         py_pdc_name = PyString_FromStringOrNULL(object->pdc_name);
5115         return py_pdc_name;
5116 }
5117
5118 static int py_NETLOGON_DB_CHANGE_set_pdc_name(PyObject *py_obj, PyObject *value, void *closure)
5119 {
5120         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(py_obj);
5121         object->pdc_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
5122         return 0;
5123 }
5124
5125 static PyObject *py_NETLOGON_DB_CHANGE_get_domain(PyObject *obj, void *closure)
5126 {
5127         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(obj);
5128         PyObject *py_domain;
5129         py_domain = PyString_FromStringOrNULL(object->domain);
5130         return py_domain;
5131 }
5132
5133 static int py_NETLOGON_DB_CHANGE_set_domain(PyObject *py_obj, PyObject *value, void *closure)
5134 {
5135         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(py_obj);
5136         object->domain = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
5137         return 0;
5138 }
5139
5140 static PyObject *py_NETLOGON_DB_CHANGE_get__pad(PyObject *obj, void *closure)
5141 {
5142         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(obj);
5143         PyObject *py__pad;
5144         py__pad = PyString_FromStringAndSize((char *)(object->_pad).data, (object->_pad).length);
5145         return py__pad;
5146 }
5147
5148 static int py_NETLOGON_DB_CHANGE_set__pad(PyObject *py_obj, PyObject *value, void *closure)
5149 {
5150         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(py_obj);
5151         object->_pad = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value), PyString_GET_SIZE(value));
5152         return 0;
5153 }
5154
5155 static PyObject *py_NETLOGON_DB_CHANGE_get_unicode_pdc_name(PyObject *obj, void *closure)
5156 {
5157         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(obj);
5158         PyObject *py_unicode_pdc_name;
5159         py_unicode_pdc_name = PyString_FromStringOrNULL(object->unicode_pdc_name);
5160         return py_unicode_pdc_name;
5161 }
5162
5163 static int py_NETLOGON_DB_CHANGE_set_unicode_pdc_name(PyObject *py_obj, PyObject *value, void *closure)
5164 {
5165         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(py_obj);
5166         object->unicode_pdc_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
5167         return 0;
5168 }
5169
5170 static PyObject *py_NETLOGON_DB_CHANGE_get_unicode_domain(PyObject *obj, void *closure)
5171 {
5172         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(obj);
5173         PyObject *py_unicode_domain;
5174         py_unicode_domain = PyString_FromStringOrNULL(object->unicode_domain);
5175         return py_unicode_domain;
5176 }
5177
5178 static int py_NETLOGON_DB_CHANGE_set_unicode_domain(PyObject *py_obj, PyObject *value, void *closure)
5179 {
5180         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(py_obj);
5181         object->unicode_domain = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
5182         return 0;
5183 }
5184
5185 static PyObject *py_NETLOGON_DB_CHANGE_get_db_count(PyObject *obj, void *closure)
5186 {
5187         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(obj);
5188         PyObject *py_db_count;
5189         py_db_count = PyInt_FromLong(object->db_count);
5190         return py_db_count;
5191 }
5192
5193 static int py_NETLOGON_DB_CHANGE_set_db_count(PyObject *py_obj, PyObject *value, void *closure)
5194 {
5195         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(py_obj);
5196         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5197         object->db_count = PyInt_AsLong(value);
5198         return 0;
5199 }
5200
5201 static PyObject *py_NETLOGON_DB_CHANGE_get_dbchange(PyObject *obj, void *closure)
5202 {
5203         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(obj);
5204         PyObject *py_dbchange;
5205         py_dbchange = PyList_New(object->db_count);
5206         if (py_dbchange == NULL) {
5207                 return NULL;
5208         }
5209         {
5210                 int dbchange_cntr_0;
5211                 for (dbchange_cntr_0 = 0; dbchange_cntr_0 < object->db_count; dbchange_cntr_0++) {
5212                         PyObject *py_dbchange_0;
5213                         py_dbchange_0 = pytalloc_reference_ex(&nbt_db_change_info_Type, object->dbchange, &object->dbchange[dbchange_cntr_0]);
5214                         PyList_SetItem(py_dbchange, dbchange_cntr_0, py_dbchange_0);
5215                 }
5216         }
5217         return py_dbchange;
5218 }
5219
5220 static int py_NETLOGON_DB_CHANGE_set_dbchange(PyObject *py_obj, PyObject *value, void *closure)
5221 {
5222         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(py_obj);
5223         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
5224         {
5225                 int dbchange_cntr_0;
5226                 object->dbchange = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->dbchange, PyList_GET_SIZE(value));
5227                 if (!object->dbchange) { return -1;; }
5228                 talloc_set_name_const(object->dbchange, "ARRAY: object->dbchange");
5229                 for (dbchange_cntr_0 = 0; dbchange_cntr_0 < PyList_GET_SIZE(value); dbchange_cntr_0++) {
5230                         PY_CHECK_TYPE(&nbt_db_change_info_Type, PyList_GET_ITEM(value, dbchange_cntr_0), return -1;);
5231                         if (talloc_reference(object->dbchange, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, dbchange_cntr_0))) == NULL) {
5232                                 PyErr_NoMemory();
5233                                 return -1;
5234                         }
5235                         object->dbchange[dbchange_cntr_0] = *(struct nbt_db_change_info *)pytalloc_get_ptr(PyList_GET_ITEM(value, dbchange_cntr_0));
5236                 }
5237         }
5238         return 0;
5239 }
5240
5241 static PyObject *py_NETLOGON_DB_CHANGE_get_sid_size(PyObject *obj, void *closure)
5242 {
5243         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(obj);
5244         PyObject *py_sid_size;
5245         py_sid_size = PyInt_FromLong(object->sid_size);
5246         return py_sid_size;
5247 }
5248
5249 static int py_NETLOGON_DB_CHANGE_set_sid_size(PyObject *py_obj, PyObject *value, void *closure)
5250 {
5251         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(py_obj);
5252         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5253         object->sid_size = PyInt_AsLong(value);
5254         return 0;
5255 }
5256
5257 static PyObject *py_NETLOGON_DB_CHANGE_get_sid(PyObject *obj, void *closure)
5258 {
5259         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(obj);
5260         PyObject *py_sid;
5261         py_sid = pytalloc_reference_ex(dom_sid_Type, pytalloc_get_mem_ctx(obj), &object->sid);
5262         return py_sid;
5263 }
5264
5265 static int py_NETLOGON_DB_CHANGE_set_sid(PyObject *py_obj, PyObject *value, void *closure)
5266 {
5267         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(py_obj);
5268         PY_CHECK_TYPE(dom_sid_Type, value, return -1;);
5269         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
5270                 PyErr_NoMemory();
5271                 return -1;
5272         }
5273         object->sid = *(struct dom_sid *)pytalloc_get_ptr(value);
5274         return 0;
5275 }
5276
5277 static PyObject *py_NETLOGON_DB_CHANGE_get_message_format_version(PyObject *obj, void *closure)
5278 {
5279         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(obj);
5280         PyObject *py_message_format_version;
5281         py_message_format_version = PyInt_FromLong(object->message_format_version);
5282         return py_message_format_version;
5283 }
5284
5285 static int py_NETLOGON_DB_CHANGE_set_message_format_version(PyObject *py_obj, PyObject *value, void *closure)
5286 {
5287         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(py_obj);
5288         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5289         object->message_format_version = PyInt_AsLong(value);
5290         return 0;
5291 }
5292
5293 static PyObject *py_NETLOGON_DB_CHANGE_get_message_token(PyObject *obj, void *closure)
5294 {
5295         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(obj);
5296         PyObject *py_message_token;
5297         py_message_token = PyInt_FromLong(object->message_token);
5298         return py_message_token;
5299 }
5300
5301 static int py_NETLOGON_DB_CHANGE_set_message_token(PyObject *py_obj, PyObject *value, void *closure)
5302 {
5303         struct NETLOGON_DB_CHANGE *object = (struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(py_obj);
5304         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5305         object->message_token = PyInt_AsLong(value);
5306         return 0;
5307 }
5308
5309 static PyGetSetDef py_NETLOGON_DB_CHANGE_getsetters[] = {
5310         { discard_const_p(char, "serial_lo"), py_NETLOGON_DB_CHANGE_get_serial_lo, py_NETLOGON_DB_CHANGE_set_serial_lo },
5311         { discard_const_p(char, "timestamp"), py_NETLOGON_DB_CHANGE_get_timestamp, py_NETLOGON_DB_CHANGE_set_timestamp },
5312         { discard_const_p(char, "pulse"), py_NETLOGON_DB_CHANGE_get_pulse, py_NETLOGON_DB_CHANGE_set_pulse },
5313         { discard_const_p(char, "random"), py_NETLOGON_DB_CHANGE_get_random, py_NETLOGON_DB_CHANGE_set_random },
5314         { discard_const_p(char, "pdc_name"), py_NETLOGON_DB_CHANGE_get_pdc_name, py_NETLOGON_DB_CHANGE_set_pdc_name },
5315         { discard_const_p(char, "domain"), py_NETLOGON_DB_CHANGE_get_domain, py_NETLOGON_DB_CHANGE_set_domain },
5316         { discard_const_p(char, "_pad"), py_NETLOGON_DB_CHANGE_get__pad, py_NETLOGON_DB_CHANGE_set__pad },
5317         { discard_const_p(char, "unicode_pdc_name"), py_NETLOGON_DB_CHANGE_get_unicode_pdc_name, py_NETLOGON_DB_CHANGE_set_unicode_pdc_name },
5318         { discard_const_p(char, "unicode_domain"), py_NETLOGON_DB_CHANGE_get_unicode_domain, py_NETLOGON_DB_CHANGE_set_unicode_domain },
5319         { discard_const_p(char, "db_count"), py_NETLOGON_DB_CHANGE_get_db_count, py_NETLOGON_DB_CHANGE_set_db_count },
5320         { discard_const_p(char, "dbchange"), py_NETLOGON_DB_CHANGE_get_dbchange, py_NETLOGON_DB_CHANGE_set_dbchange },
5321         { discard_const_p(char, "sid_size"), py_NETLOGON_DB_CHANGE_get_sid_size, py_NETLOGON_DB_CHANGE_set_sid_size },
5322         { discard_const_p(char, "sid"), py_NETLOGON_DB_CHANGE_get_sid, py_NETLOGON_DB_CHANGE_set_sid },
5323         { discard_const_p(char, "message_format_version"), py_NETLOGON_DB_CHANGE_get_message_format_version, py_NETLOGON_DB_CHANGE_set_message_format_version },
5324         { discard_const_p(char, "message_token"), py_NETLOGON_DB_CHANGE_get_message_token, py_NETLOGON_DB_CHANGE_set_message_token },
5325         { NULL }
5326 };
5327
5328 static PyObject *py_NETLOGON_DB_CHANGE_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5329 {
5330         return pytalloc_new(struct NETLOGON_DB_CHANGE, type);
5331 }
5332
5333
5334 static PyTypeObject NETLOGON_DB_CHANGE_Type = {
5335         PyObject_HEAD_INIT(NULL) 0,
5336         .tp_name = "nbt.NETLOGON_DB_CHANGE",
5337         .tp_getset = py_NETLOGON_DB_CHANGE_getsetters,
5338         .tp_methods = NULL,
5339         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5340         .tp_basicsize = sizeof(pytalloc_Object),
5341         .tp_new = py_NETLOGON_DB_CHANGE_new,
5342 };
5343
5344 PyObject *py_import_nbt_netlogon_request(TALLOC_CTX *mem_ctx, int level, union nbt_netlogon_request *in)
5345 {
5346         PyObject *ret;
5347
5348         switch (level) {
5349                 case LOGON_REQUEST:
5350                         ret = pytalloc_reference_ex(&NETLOGON_LOGON_REQUEST_Type, mem_ctx, &in->logon0);
5351                         return ret;
5352
5353                 case LOGON_SAM_LOGON_REQUEST:
5354                         ret = pytalloc_reference_ex(&NETLOGON_SAM_LOGON_REQUEST_Type, mem_ctx, &in->logon);
5355                         return ret;
5356
5357                 case LOGON_PRIMARY_QUERY:
5358                         ret = pytalloc_reference_ex(&nbt_netlogon_query_for_pdc_Type, mem_ctx, &in->pdc);
5359                         return ret;
5360
5361                 case NETLOGON_ANNOUNCE_UAS:
5362                         ret = pytalloc_reference_ex(&NETLOGON_DB_CHANGE_Type, mem_ctx, &in->uas);
5363                         return ret;
5364
5365         }
5366         PyErr_SetString(PyExc_TypeError, "unknown union level");
5367         return NULL;
5368 }
5369
5370 union nbt_netlogon_request *py_export_nbt_netlogon_request(TALLOC_CTX *mem_ctx, int level, PyObject *in)
5371 {
5372         union nbt_netlogon_request *ret = talloc_zero(mem_ctx, union nbt_netlogon_request);
5373         switch (level) {
5374                 case LOGON_REQUEST:
5375                         PY_CHECK_TYPE(&NETLOGON_LOGON_REQUEST_Type, in, talloc_free(ret); return NULL;);
5376                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
5377                                 PyErr_NoMemory();
5378                                 talloc_free(ret); return NULL;
5379                         }
5380                         ret->logon0 = *(struct NETLOGON_LOGON_REQUEST *)pytalloc_get_ptr(in);
5381                         break;
5382
5383                 case LOGON_SAM_LOGON_REQUEST:
5384                         PY_CHECK_TYPE(&NETLOGON_SAM_LOGON_REQUEST_Type, in, talloc_free(ret); return NULL;);
5385                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
5386                                 PyErr_NoMemory();
5387                                 talloc_free(ret); return NULL;
5388                         }
5389                         ret->logon = *(struct NETLOGON_SAM_LOGON_REQUEST *)pytalloc_get_ptr(in);
5390                         break;
5391
5392                 case LOGON_PRIMARY_QUERY:
5393                         PY_CHECK_TYPE(&nbt_netlogon_query_for_pdc_Type, in, talloc_free(ret); return NULL;);
5394                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
5395                                 PyErr_NoMemory();
5396                                 talloc_free(ret); return NULL;
5397                         }
5398                         ret->pdc = *(struct nbt_netlogon_query_for_pdc *)pytalloc_get_ptr(in);
5399                         break;
5400
5401                 case NETLOGON_ANNOUNCE_UAS:
5402                         PY_CHECK_TYPE(&NETLOGON_DB_CHANGE_Type, in, talloc_free(ret); return NULL;);
5403                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
5404                                 PyErr_NoMemory();
5405                                 talloc_free(ret); return NULL;
5406                         }
5407                         ret->uas = *(struct NETLOGON_DB_CHANGE *)pytalloc_get_ptr(in);
5408                         break;
5409
5410                 default:
5411                         PyErr_SetString(PyExc_TypeError, "invalid union level value");
5412                         talloc_free(ret);
5413                         ret = NULL;
5414         }
5415
5416         return ret;
5417 }
5418
5419
5420 static PyObject *py_nbt_netlogon_packet_get_command(PyObject *obj, void *closure)
5421 {
5422         struct nbt_netlogon_packet *object = (struct nbt_netlogon_packet *)pytalloc_get_ptr(obj);
5423         PyObject *py_command;
5424         py_command = PyInt_FromLong(object->command);
5425         return py_command;
5426 }
5427
5428 static int py_nbt_netlogon_packet_set_command(PyObject *py_obj, PyObject *value, void *closure)
5429 {
5430         struct nbt_netlogon_packet *object = (struct nbt_netlogon_packet *)pytalloc_get_ptr(py_obj);
5431         if (PyLong_Check(value)) {
5432                 object->command = PyLong_AsLongLong(value);
5433         } else if (PyInt_Check(value)) {
5434                 object->command = PyInt_AsLong(value);
5435         } else {
5436                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
5437                   PyInt_Type.tp_name, PyLong_Type.tp_name);
5438                 return -1;
5439         }
5440         return 0;
5441 }
5442
5443 static PyObject *py_nbt_netlogon_packet_get_req(PyObject *obj, void *closure)
5444 {
5445         struct nbt_netlogon_packet *object = (struct nbt_netlogon_packet *)pytalloc_get_ptr(obj);
5446         PyObject *py_req;
5447         py_req = py_import_nbt_netlogon_request(pytalloc_get_mem_ctx(obj), object->command, &object->req);
5448         if (py_req == NULL) {
5449                 return NULL;
5450         }
5451         return py_req;
5452 }
5453
5454 static int py_nbt_netlogon_packet_set_req(PyObject *py_obj, PyObject *value, void *closure)
5455 {
5456         struct nbt_netlogon_packet *object = (struct nbt_netlogon_packet *)pytalloc_get_ptr(py_obj);
5457         {
5458                 union nbt_netlogon_request *req_switch_0;
5459                 req_switch_0 = py_export_nbt_netlogon_request(pytalloc_get_mem_ctx(py_obj), object->command, value);
5460                 if (req_switch_0 == NULL) {
5461                         return -1;
5462                 }
5463                 object->req = *req_switch_0;
5464         }
5465         return 0;
5466 }
5467
5468 static PyGetSetDef py_nbt_netlogon_packet_getsetters[] = {
5469         { discard_const_p(char, "command"), py_nbt_netlogon_packet_get_command, py_nbt_netlogon_packet_set_command },
5470         { discard_const_p(char, "req"), py_nbt_netlogon_packet_get_req, py_nbt_netlogon_packet_set_req },
5471         { NULL }
5472 };
5473
5474 static PyObject *py_nbt_netlogon_packet_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5475 {
5476         return pytalloc_new(struct nbt_netlogon_packet, type);
5477 }
5478
5479 static PyObject *py_nbt_netlogon_packet_ndr_pack(PyObject *py_obj)
5480 {
5481         struct nbt_netlogon_packet *object = (struct nbt_netlogon_packet *)pytalloc_get_ptr(py_obj);
5482         DATA_BLOB blob;
5483         enum ndr_err_code err;
5484         err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_nbt_netlogon_packet);
5485         if (err != NDR_ERR_SUCCESS) {
5486                 PyErr_SetNdrError(err);
5487                 return NULL;
5488         }
5489
5490         return PyString_FromStringAndSize((char *)blob.data, blob.length);
5491 }
5492
5493 static PyObject *py_nbt_netlogon_packet_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
5494 {
5495         struct nbt_netlogon_packet *object = (struct nbt_netlogon_packet *)pytalloc_get_ptr(py_obj);
5496         DATA_BLOB blob;
5497         int blob_length = 0;
5498         enum ndr_err_code err;
5499         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
5500         PyObject *allow_remaining_obj = NULL;
5501         bool allow_remaining = false;
5502
5503         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
5504                 discard_const_p(char *, kwnames),
5505                 &blob.data, &blob_length,
5506                 &allow_remaining_obj)) {
5507                 return NULL;
5508         }
5509         blob.length = blob_length;
5510
5511         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
5512                 allow_remaining = true;
5513         }
5514
5515         if (allow_remaining) {
5516                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_nbt_netlogon_packet);
5517         } else {
5518                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_nbt_netlogon_packet);
5519         }
5520         if (err != NDR_ERR_SUCCESS) {
5521                 PyErr_SetNdrError(err);
5522                 return NULL;
5523         }
5524
5525         Py_RETURN_NONE;
5526 }
5527
5528 static PyObject *py_nbt_netlogon_packet_ndr_print(PyObject *py_obj)
5529 {
5530         struct nbt_netlogon_packet *object = (struct nbt_netlogon_packet *)pytalloc_get_ptr(py_obj);
5531         PyObject *ret;
5532         char *retstr;
5533
5534         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_nbt_netlogon_packet, "nbt_netlogon_packet", object);
5535         ret = PyString_FromString(retstr);
5536         talloc_free(retstr);
5537
5538         return ret;
5539 }
5540
5541 static PyMethodDef py_nbt_netlogon_packet_methods[] = {
5542         { "__ndr_pack__", (PyCFunction)py_nbt_netlogon_packet_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
5543         { "__ndr_unpack__", (PyCFunction)py_nbt_netlogon_packet_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
5544         { "__ndr_print__", (PyCFunction)py_nbt_netlogon_packet_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
5545         { NULL, NULL, 0, NULL }
5546 };
5547
5548
5549 static PyTypeObject nbt_netlogon_packet_Type = {
5550         PyObject_HEAD_INIT(NULL) 0,
5551         .tp_name = "nbt.netlogon_packet",
5552         .tp_getset = py_nbt_netlogon_packet_getsetters,
5553         .tp_methods = py_nbt_netlogon_packet_methods,
5554         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5555         .tp_basicsize = sizeof(pytalloc_Object),
5556         .tp_new = py_nbt_netlogon_packet_new,
5557 };
5558
5559
5560 static PyObject *py_nbt_browse_host_announcement_get_UpdateCount(PyObject *obj, void *closure)
5561 {
5562         struct nbt_browse_host_announcement *object = (struct nbt_browse_host_announcement *)pytalloc_get_ptr(obj);
5563         PyObject *py_UpdateCount;
5564         py_UpdateCount = PyInt_FromLong(object->UpdateCount);
5565         return py_UpdateCount;
5566 }
5567
5568 static int py_nbt_browse_host_announcement_set_UpdateCount(PyObject *py_obj, PyObject *value, void *closure)
5569 {
5570         struct nbt_browse_host_announcement *object = (struct nbt_browse_host_announcement *)pytalloc_get_ptr(py_obj);
5571         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5572         object->UpdateCount = PyInt_AsLong(value);
5573         return 0;
5574 }
5575
5576 static PyObject *py_nbt_browse_host_announcement_get_Periodicity(PyObject *obj, void *closure)
5577 {
5578         struct nbt_browse_host_announcement *object = (struct nbt_browse_host_announcement *)pytalloc_get_ptr(obj);
5579         PyObject *py_Periodicity;
5580         py_Periodicity = PyInt_FromLong(object->Periodicity);
5581         return py_Periodicity;
5582 }
5583
5584 static int py_nbt_browse_host_announcement_set_Periodicity(PyObject *py_obj, PyObject *value, void *closure)
5585 {
5586         struct nbt_browse_host_announcement *object = (struct nbt_browse_host_announcement *)pytalloc_get_ptr(py_obj);
5587         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5588         object->Periodicity = PyInt_AsLong(value);
5589         return 0;
5590 }
5591
5592 static PyObject *py_nbt_browse_host_announcement_get_ServerName(PyObject *obj, void *closure)
5593 {
5594         struct nbt_browse_host_announcement *object = (struct nbt_browse_host_announcement *)pytalloc_get_ptr(obj);
5595         PyObject *py_ServerName;
5596         if (object->ServerName == NULL) {
5597                 py_ServerName = Py_None;
5598                 Py_INCREF(py_ServerName);
5599         } else {
5600                 py_ServerName = PyUnicode_Decode(object->ServerName, strlen(object->ServerName), "utf-8", "ignore");
5601         }
5602         return py_ServerName;
5603 }
5604
5605 static int py_nbt_browse_host_announcement_set_ServerName(PyObject *py_obj, PyObject *value, void *closure)
5606 {
5607         struct nbt_browse_host_announcement *object = (struct nbt_browse_host_announcement *)pytalloc_get_ptr(py_obj);
5608         if (PyUnicode_Check(value)) {
5609                 object->ServerName = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
5610         } else if (PyString_Check(value)) {
5611                 object->ServerName = PyString_AS_STRING(value);
5612         } else {
5613                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
5614                 return -1;
5615         }
5616         return 0;
5617 }
5618
5619 static PyObject *py_nbt_browse_host_announcement_get_OSMajor(PyObject *obj, void *closure)
5620 {
5621         struct nbt_browse_host_announcement *object = (struct nbt_browse_host_announcement *)pytalloc_get_ptr(obj);
5622         PyObject *py_OSMajor;
5623         py_OSMajor = PyInt_FromLong(object->OSMajor);
5624         return py_OSMajor;
5625 }
5626
5627 static int py_nbt_browse_host_announcement_set_OSMajor(PyObject *py_obj, PyObject *value, void *closure)
5628 {
5629         struct nbt_browse_host_announcement *object = (struct nbt_browse_host_announcement *)pytalloc_get_ptr(py_obj);
5630         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5631         object->OSMajor = PyInt_AsLong(value);
5632         return 0;
5633 }
5634
5635 static PyObject *py_nbt_browse_host_announcement_get_OSMinor(PyObject *obj, void *closure)
5636 {
5637         struct nbt_browse_host_announcement *object = (struct nbt_browse_host_announcement *)pytalloc_get_ptr(obj);
5638         PyObject *py_OSMinor;
5639         py_OSMinor = PyInt_FromLong(object->OSMinor);
5640         return py_OSMinor;
5641 }
5642
5643 static int py_nbt_browse_host_announcement_set_OSMinor(PyObject *py_obj, PyObject *value, void *closure)
5644 {
5645         struct nbt_browse_host_announcement *object = (struct nbt_browse_host_announcement *)pytalloc_get_ptr(py_obj);
5646         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5647         object->OSMinor = PyInt_AsLong(value);
5648         return 0;
5649 }
5650
5651 static PyObject *py_nbt_browse_host_announcement_get_ServerType(PyObject *obj, void *closure)
5652 {
5653         struct nbt_browse_host_announcement *object = (struct nbt_browse_host_announcement *)pytalloc_get_ptr(obj);
5654         PyObject *py_ServerType;
5655         py_ServerType = PyInt_FromLong(object->ServerType);
5656         return py_ServerType;
5657 }
5658
5659 static int py_nbt_browse_host_announcement_set_ServerType(PyObject *py_obj, PyObject *value, void *closure)
5660 {
5661         struct nbt_browse_host_announcement *object = (struct nbt_browse_host_announcement *)pytalloc_get_ptr(py_obj);
5662         if (PyLong_Check(value)) {
5663                 object->ServerType = PyLong_AsLongLong(value);
5664         } else if (PyInt_Check(value)) {
5665                 object->ServerType = PyInt_AsLong(value);
5666         } else {
5667                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
5668                   PyInt_Type.tp_name, PyLong_Type.tp_name);
5669                 return -1;
5670         }
5671         return 0;
5672 }
5673
5674 static PyObject *py_nbt_browse_host_announcement_get_BroMajorVer(PyObject *obj, void *closure)
5675 {
5676         struct nbt_browse_host_announcement *object = (struct nbt_browse_host_announcement *)pytalloc_get_ptr(obj);
5677         PyObject *py_BroMajorVer;
5678         py_BroMajorVer = PyInt_FromLong(object->BroMajorVer);
5679         return py_BroMajorVer;
5680 }
5681
5682 static int py_nbt_browse_host_announcement_set_BroMajorVer(PyObject *py_obj, PyObject *value, void *closure)
5683 {
5684         struct nbt_browse_host_announcement *object = (struct nbt_browse_host_announcement *)pytalloc_get_ptr(py_obj);
5685         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5686         object->BroMajorVer = PyInt_AsLong(value);
5687         return 0;
5688 }
5689
5690 static PyObject *py_nbt_browse_host_announcement_get_BroMinorVer(PyObject *obj, void *closure)
5691 {
5692         struct nbt_browse_host_announcement *object = (struct nbt_browse_host_announcement *)pytalloc_get_ptr(obj);
5693         PyObject *py_BroMinorVer;
5694         py_BroMinorVer = PyInt_FromLong(object->BroMinorVer);
5695         return py_BroMinorVer;
5696 }
5697
5698 static int py_nbt_browse_host_announcement_set_BroMinorVer(PyObject *py_obj, PyObject *value, void *closure)
5699 {
5700         struct nbt_browse_host_announcement *object = (struct nbt_browse_host_announcement *)pytalloc_get_ptr(py_obj);
5701         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5702         object->BroMinorVer = PyInt_AsLong(value);
5703         return 0;
5704 }
5705
5706 static PyObject *py_nbt_browse_host_announcement_get_Signature(PyObject *obj, void *closure)
5707 {
5708         struct nbt_browse_host_announcement *object = (struct nbt_browse_host_announcement *)pytalloc_get_ptr(obj);
5709         PyObject *py_Signature;
5710         py_Signature = PyInt_FromLong(object->Signature);
5711         return py_Signature;
5712 }
5713
5714 static int py_nbt_browse_host_announcement_set_Signature(PyObject *py_obj, PyObject *value, void *closure)
5715 {
5716         struct nbt_browse_host_announcement *object = (struct nbt_browse_host_announcement *)pytalloc_get_ptr(py_obj);
5717         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5718         object->Signature = PyInt_AsLong(value);
5719         return 0;
5720 }
5721
5722 static PyObject *py_nbt_browse_host_announcement_get_Comment(PyObject *obj, void *closure)
5723 {
5724         struct nbt_browse_host_announcement *object = (struct nbt_browse_host_announcement *)pytalloc_get_ptr(obj);
5725         PyObject *py_Comment;
5726         py_Comment = PyString_FromStringOrNULL(object->Comment);
5727         return py_Comment;
5728 }
5729
5730 static int py_nbt_browse_host_announcement_set_Comment(PyObject *py_obj, PyObject *value, void *closure)
5731 {
5732         struct nbt_browse_host_announcement *object = (struct nbt_browse_host_announcement *)pytalloc_get_ptr(py_obj);
5733         object->Comment = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
5734         return 0;
5735 }
5736
5737 static PyGetSetDef py_nbt_browse_host_announcement_getsetters[] = {
5738         { discard_const_p(char, "UpdateCount"), py_nbt_browse_host_announcement_get_UpdateCount, py_nbt_browse_host_announcement_set_UpdateCount },
5739         { discard_const_p(char, "Periodicity"), py_nbt_browse_host_announcement_get_Periodicity, py_nbt_browse_host_announcement_set_Periodicity },
5740         { discard_const_p(char, "ServerName"), py_nbt_browse_host_announcement_get_ServerName, py_nbt_browse_host_announcement_set_ServerName },
5741         { discard_const_p(char, "OSMajor"), py_nbt_browse_host_announcement_get_OSMajor, py_nbt_browse_host_announcement_set_OSMajor },
5742         { discard_const_p(char, "OSMinor"), py_nbt_browse_host_announcement_get_OSMinor, py_nbt_browse_host_announcement_set_OSMinor },
5743         { discard_const_p(char, "ServerType"), py_nbt_browse_host_announcement_get_ServerType, py_nbt_browse_host_announcement_set_ServerType },
5744         { discard_const_p(char, "BroMajorVer"), py_nbt_browse_host_announcement_get_BroMajorVer, py_nbt_browse_host_announcement_set_BroMajorVer },
5745         { discard_const_p(char, "BroMinorVer"), py_nbt_browse_host_announcement_get_BroMinorVer, py_nbt_browse_host_announcement_set_BroMinorVer },
5746         { discard_const_p(char, "Signature"), py_nbt_browse_host_announcement_get_Signature, py_nbt_browse_host_announcement_set_Signature },
5747         { discard_const_p(char, "Comment"), py_nbt_browse_host_announcement_get_Comment, py_nbt_browse_host_announcement_set_Comment },
5748         { NULL }
5749 };
5750
5751 static PyObject *py_nbt_browse_host_announcement_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5752 {
5753         return pytalloc_new(struct nbt_browse_host_announcement, type);
5754 }
5755
5756
5757 static PyTypeObject nbt_browse_host_announcement_Type = {
5758         PyObject_HEAD_INIT(NULL) 0,
5759         .tp_name = "nbt.browse_host_announcement",
5760         .tp_getset = py_nbt_browse_host_announcement_getsetters,
5761         .tp_methods = NULL,
5762         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5763         .tp_basicsize = sizeof(pytalloc_Object),
5764         .tp_new = py_nbt_browse_host_announcement_new,
5765 };
5766
5767
5768 static PyObject *py_nbt_browse_announcement_request_get_Unused(PyObject *obj, void *closure)
5769 {
5770         struct nbt_browse_announcement_request *object = (struct nbt_browse_announcement_request *)pytalloc_get_ptr(obj);
5771         PyObject *py_Unused;
5772         py_Unused = PyInt_FromLong(object->Unused);
5773         return py_Unused;
5774 }
5775
5776 static int py_nbt_browse_announcement_request_set_Unused(PyObject *py_obj, PyObject *value, void *closure)
5777 {
5778         struct nbt_browse_announcement_request *object = (struct nbt_browse_announcement_request *)pytalloc_get_ptr(py_obj);
5779         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5780         object->Unused = PyInt_AsLong(value);
5781         return 0;
5782 }
5783
5784 static PyObject *py_nbt_browse_announcement_request_get_ResponseName(PyObject *obj, void *closure)
5785 {
5786         struct nbt_browse_announcement_request *object = (struct nbt_browse_announcement_request *)pytalloc_get_ptr(obj);
5787         PyObject *py_ResponseName;
5788         py_ResponseName = PyString_FromStringOrNULL(object->ResponseName);
5789         return py_ResponseName;
5790 }
5791
5792 static int py_nbt_browse_announcement_request_set_ResponseName(PyObject *py_obj, PyObject *value, void *closure)
5793 {
5794         struct nbt_browse_announcement_request *object = (struct nbt_browse_announcement_request *)pytalloc_get_ptr(py_obj);
5795         object->ResponseName = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
5796         return 0;
5797 }
5798
5799 static PyGetSetDef py_nbt_browse_announcement_request_getsetters[] = {
5800         { discard_const_p(char, "Unused"), py_nbt_browse_announcement_request_get_Unused, py_nbt_browse_announcement_request_set_Unused },
5801         { discard_const_p(char, "ResponseName"), py_nbt_browse_announcement_request_get_ResponseName, py_nbt_browse_announcement_request_set_ResponseName },
5802         { NULL }
5803 };
5804
5805 static PyObject *py_nbt_browse_announcement_request_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5806 {
5807         return pytalloc_new(struct nbt_browse_announcement_request, type);
5808 }
5809
5810
5811 static PyTypeObject nbt_browse_announcement_request_Type = {
5812         PyObject_HEAD_INIT(NULL) 0,
5813         .tp_name = "nbt.browse_announcement_request",
5814         .tp_getset = py_nbt_browse_announcement_request_getsetters,
5815         .tp_methods = NULL,
5816         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5817         .tp_basicsize = sizeof(pytalloc_Object),
5818         .tp_new = py_nbt_browse_announcement_request_new,
5819 };
5820
5821
5822 static PyObject *py_nbt_browse_election_request_get_Version(PyObject *obj, void *closure)
5823 {
5824         struct nbt_browse_election_request *object = (struct nbt_browse_election_request *)pytalloc_get_ptr(obj);
5825         PyObject *py_Version;
5826         py_Version = PyInt_FromLong(object->Version);
5827         return py_Version;
5828 }
5829
5830 static int py_nbt_browse_election_request_set_Version(PyObject *py_obj, PyObject *value, void *closure)
5831 {
5832         struct nbt_browse_election_request *object = (struct nbt_browse_election_request *)pytalloc_get_ptr(py_obj);
5833         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5834         object->Version = PyInt_AsLong(value);
5835         return 0;
5836 }
5837
5838 static PyObject *py_nbt_browse_election_request_get_Criteria(PyObject *obj, void *closure)
5839 {
5840         struct nbt_browse_election_request *object = (struct nbt_browse_election_request *)pytalloc_get_ptr(obj);
5841         PyObject *py_Criteria;
5842         py_Criteria = PyInt_FromLong(object->Criteria);
5843         return py_Criteria;
5844 }
5845
5846 static int py_nbt_browse_election_request_set_Criteria(PyObject *py_obj, PyObject *value, void *closure)
5847 {
5848         struct nbt_browse_election_request *object = (struct nbt_browse_election_request *)pytalloc_get_ptr(py_obj);
5849         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5850         object->Criteria = PyInt_AsLong(value);
5851         return 0;
5852 }
5853
5854 static PyObject *py_nbt_browse_election_request_get_UpTime(PyObject *obj, void *closure)
5855 {
5856         struct nbt_browse_election_request *object = (struct nbt_browse_election_request *)pytalloc_get_ptr(obj);
5857         PyObject *py_UpTime;
5858         py_UpTime = PyInt_FromLong(object->UpTime);
5859         return py_UpTime;
5860 }
5861
5862 static int py_nbt_browse_election_request_set_UpTime(PyObject *py_obj, PyObject *value, void *closure)
5863 {
5864         struct nbt_browse_election_request *object = (struct nbt_browse_election_request *)pytalloc_get_ptr(py_obj);
5865         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5866         object->UpTime = PyInt_AsLong(value);
5867         return 0;
5868 }
5869
5870 static PyObject *py_nbt_browse_election_request_get_Reserved(PyObject *obj, void *closure)
5871 {
5872         struct nbt_browse_election_request *object = (struct nbt_browse_election_request *)pytalloc_get_ptr(obj);
5873         PyObject *py_Reserved;
5874         py_Reserved = PyInt_FromLong(object->Reserved);
5875         return py_Reserved;
5876 }
5877
5878 static int py_nbt_browse_election_request_set_Reserved(PyObject *py_obj, PyObject *value, void *closure)
5879 {
5880         struct nbt_browse_election_request *object = (struct nbt_browse_election_request *)pytalloc_get_ptr(py_obj);
5881         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5882         object->Reserved = PyInt_AsLong(value);
5883         return 0;
5884 }
5885
5886 static PyObject *py_nbt_browse_election_request_get_ServerName(PyObject *obj, void *closure)
5887 {
5888         struct nbt_browse_election_request *object = (struct nbt_browse_election_request *)pytalloc_get_ptr(obj);
5889         PyObject *py_ServerName;
5890         py_ServerName = PyString_FromStringOrNULL(object->ServerName);
5891         return py_ServerName;
5892 }
5893
5894 static int py_nbt_browse_election_request_set_ServerName(PyObject *py_obj, PyObject *value, void *closure)
5895 {
5896         struct nbt_browse_election_request *object = (struct nbt_browse_election_request *)pytalloc_get_ptr(py_obj);
5897         object->ServerName = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
5898         return 0;
5899 }
5900
5901 static PyGetSetDef py_nbt_browse_election_request_getsetters[] = {
5902         { discard_const_p(char, "Version"), py_nbt_browse_election_request_get_Version, py_nbt_browse_election_request_set_Version },
5903         { discard_const_p(char, "Criteria"), py_nbt_browse_election_request_get_Criteria, py_nbt_browse_election_request_set_Criteria },
5904         { discard_const_p(char, "UpTime"), py_nbt_browse_election_request_get_UpTime, py_nbt_browse_election_request_set_UpTime },
5905         { discard_const_p(char, "Reserved"), py_nbt_browse_election_request_get_Reserved, py_nbt_browse_election_request_set_Reserved },
5906         { discard_const_p(char, "ServerName"), py_nbt_browse_election_request_get_ServerName, py_nbt_browse_election_request_set_ServerName },
5907         { NULL }
5908 };
5909
5910 static PyObject *py_nbt_browse_election_request_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5911 {
5912         return pytalloc_new(struct nbt_browse_election_request, type);
5913 }
5914
5915
5916 static PyTypeObject nbt_browse_election_request_Type = {
5917         PyObject_HEAD_INIT(NULL) 0,
5918         .tp_name = "nbt.browse_election_request",
5919         .tp_getset = py_nbt_browse_election_request_getsetters,
5920         .tp_methods = NULL,
5921         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5922         .tp_basicsize = sizeof(pytalloc_Object),
5923         .tp_new = py_nbt_browse_election_request_new,
5924 };
5925
5926
5927 static PyObject *py_nbt_browse_backup_list_request_get_ReqCount(PyObject *obj, void *closure)
5928 {
5929         struct nbt_browse_backup_list_request *object = (struct nbt_browse_backup_list_request *)pytalloc_get_ptr(obj);
5930         PyObject *py_ReqCount;
5931         py_ReqCount = PyInt_FromLong(object->ReqCount);
5932         return py_ReqCount;
5933 }
5934
5935 static int py_nbt_browse_backup_list_request_set_ReqCount(PyObject *py_obj, PyObject *value, void *closure)
5936 {
5937         struct nbt_browse_backup_list_request *object = (struct nbt_browse_backup_list_request *)pytalloc_get_ptr(py_obj);
5938         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5939         object->ReqCount = PyInt_AsLong(value);
5940         return 0;
5941 }
5942
5943 static PyObject *py_nbt_browse_backup_list_request_get_Token(PyObject *obj, void *closure)
5944 {
5945         struct nbt_browse_backup_list_request *object = (struct nbt_browse_backup_list_request *)pytalloc_get_ptr(obj);
5946         PyObject *py_Token;
5947         py_Token = PyInt_FromLong(object->Token);
5948         return py_Token;
5949 }
5950
5951 static int py_nbt_browse_backup_list_request_set_Token(PyObject *py_obj, PyObject *value, void *closure)
5952 {
5953         struct nbt_browse_backup_list_request *object = (struct nbt_browse_backup_list_request *)pytalloc_get_ptr(py_obj);
5954         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5955         object->Token = PyInt_AsLong(value);
5956         return 0;
5957 }
5958
5959 static PyGetSetDef py_nbt_browse_backup_list_request_getsetters[] = {
5960         { discard_const_p(char, "ReqCount"), py_nbt_browse_backup_list_request_get_ReqCount, py_nbt_browse_backup_list_request_set_ReqCount },
5961         { discard_const_p(char, "Token"), py_nbt_browse_backup_list_request_get_Token, py_nbt_browse_backup_list_request_set_Token },
5962         { NULL }
5963 };
5964
5965 static PyObject *py_nbt_browse_backup_list_request_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5966 {
5967         return pytalloc_new(struct nbt_browse_backup_list_request, type);
5968 }
5969
5970
5971 static PyTypeObject nbt_browse_backup_list_request_Type = {
5972         PyObject_HEAD_INIT(NULL) 0,
5973         .tp_name = "nbt.browse_backup_list_request",
5974         .tp_getset = py_nbt_browse_backup_list_request_getsetters,
5975         .tp_methods = NULL,
5976         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5977         .tp_basicsize = sizeof(pytalloc_Object),
5978         .tp_new = py_nbt_browse_backup_list_request_new,
5979 };
5980
5981
5982 static PyObject *py_nbt_browse_backup_list_response_get_BackupCount(PyObject *obj, void *closure)
5983 {
5984         struct nbt_browse_backup_list_response *object = (struct nbt_browse_backup_list_response *)pytalloc_get_ptr(obj);
5985         PyObject *py_BackupCount;
5986         py_BackupCount = PyInt_FromLong(object->BackupCount);
5987         return py_BackupCount;
5988 }
5989
5990 static int py_nbt_browse_backup_list_response_set_BackupCount(PyObject *py_obj, PyObject *value, void *closure)
5991 {
5992         struct nbt_browse_backup_list_response *object = (struct nbt_browse_backup_list_response *)pytalloc_get_ptr(py_obj);
5993         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
5994         object->BackupCount = PyInt_AsLong(value);
5995         return 0;
5996 }
5997
5998 static PyObject *py_nbt_browse_backup_list_response_get_Token(PyObject *obj, void *closure)
5999 {
6000         struct nbt_browse_backup_list_response *object = (struct nbt_browse_backup_list_response *)pytalloc_get_ptr(obj);
6001         PyObject *py_Token;
6002         py_Token = PyInt_FromLong(object->Token);
6003         return py_Token;
6004 }
6005
6006 static int py_nbt_browse_backup_list_response_set_Token(PyObject *py_obj, PyObject *value, void *closure)
6007 {
6008         struct nbt_browse_backup_list_response *object = (struct nbt_browse_backup_list_response *)pytalloc_get_ptr(py_obj);
6009         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6010         object->Token = PyInt_AsLong(value);
6011         return 0;
6012 }
6013
6014 static PyObject *py_nbt_browse_backup_list_response_get_BackupServerList(PyObject *obj, void *closure)
6015 {
6016         struct nbt_browse_backup_list_response *object = (struct nbt_browse_backup_list_response *)pytalloc_get_ptr(obj);
6017         PyObject *py_BackupServerList;
6018         py_BackupServerList = PyList_New(object->BackupCount);
6019         if (py_BackupServerList == NULL) {
6020                 return NULL;
6021         }
6022         {
6023                 int BackupServerList_cntr_0;
6024                 for (BackupServerList_cntr_0 = 0; BackupServerList_cntr_0 < object->BackupCount; BackupServerList_cntr_0++) {
6025                         PyObject *py_BackupServerList_0;
6026                         py_BackupServerList_0 = pytalloc_reference_ex(&nbt_name_Type, object->BackupServerList, &object->BackupServerList[BackupServerList_cntr_0]);
6027                         PyList_SetItem(py_BackupServerList, BackupServerList_cntr_0, py_BackupServerList_0);
6028                 }
6029         }
6030         return py_BackupServerList;
6031 }
6032
6033 static int py_nbt_browse_backup_list_response_set_BackupServerList(PyObject *py_obj, PyObject *value, void *closure)
6034 {
6035         struct nbt_browse_backup_list_response *object = (struct nbt_browse_backup_list_response *)pytalloc_get_ptr(py_obj);
6036         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
6037         {
6038                 int BackupServerList_cntr_0;
6039                 object->BackupServerList = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->BackupServerList, PyList_GET_SIZE(value));
6040                 if (!object->BackupServerList) { return -1;; }
6041                 talloc_set_name_const(object->BackupServerList, "ARRAY: object->BackupServerList");
6042                 for (BackupServerList_cntr_0 = 0; BackupServerList_cntr_0 < PyList_GET_SIZE(value); BackupServerList_cntr_0++) {
6043                         PY_CHECK_TYPE(&nbt_name_Type, PyList_GET_ITEM(value, BackupServerList_cntr_0), return -1;);
6044                         if (talloc_reference(object->BackupServerList, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, BackupServerList_cntr_0))) == NULL) {
6045                                 PyErr_NoMemory();
6046                                 return -1;
6047                         }
6048                         object->BackupServerList[BackupServerList_cntr_0] = *(struct nbt_name *)pytalloc_get_ptr(PyList_GET_ITEM(value, BackupServerList_cntr_0));
6049                 }
6050         }
6051         return 0;
6052 }
6053
6054 static PyGetSetDef py_nbt_browse_backup_list_response_getsetters[] = {
6055         { discard_const_p(char, "BackupCount"), py_nbt_browse_backup_list_response_get_BackupCount, py_nbt_browse_backup_list_response_set_BackupCount },
6056         { discard_const_p(char, "Token"), py_nbt_browse_backup_list_response_get_Token, py_nbt_browse_backup_list_response_set_Token },
6057         { discard_const_p(char, "BackupServerList"), py_nbt_browse_backup_list_response_get_BackupServerList, py_nbt_browse_backup_list_response_set_BackupServerList },
6058         { NULL }
6059 };
6060
6061 static PyObject *py_nbt_browse_backup_list_response_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
6062 {
6063         return pytalloc_new(struct nbt_browse_backup_list_response, type);
6064 }
6065
6066
6067 static PyTypeObject nbt_browse_backup_list_response_Type = {
6068         PyObject_HEAD_INIT(NULL) 0,
6069         .tp_name = "nbt.browse_backup_list_response",
6070         .tp_getset = py_nbt_browse_backup_list_response_getsetters,
6071         .tp_methods = NULL,
6072         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6073         .tp_basicsize = sizeof(pytalloc_Object),
6074         .tp_new = py_nbt_browse_backup_list_response_new,
6075 };
6076
6077
6078 static PyObject *py_nbt_browse_become_backup_get_BrowserName(PyObject *obj, void *closure)
6079 {
6080         struct nbt_browse_become_backup *object = (struct nbt_browse_become_backup *)pytalloc_get_ptr(obj);
6081         PyObject *py_BrowserName;
6082         py_BrowserName = PyString_FromStringOrNULL(object->BrowserName);
6083         return py_BrowserName;
6084 }
6085
6086 static int py_nbt_browse_become_backup_set_BrowserName(PyObject *py_obj, PyObject *value, void *closure)
6087 {
6088         struct nbt_browse_become_backup *object = (struct nbt_browse_become_backup *)pytalloc_get_ptr(py_obj);
6089         object->BrowserName = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
6090         return 0;
6091 }
6092
6093 static PyGetSetDef py_nbt_browse_become_backup_getsetters[] = {
6094         { discard_const_p(char, "BrowserName"), py_nbt_browse_become_backup_get_BrowserName, py_nbt_browse_become_backup_set_BrowserName },
6095         { NULL }
6096 };
6097
6098 static PyObject *py_nbt_browse_become_backup_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
6099 {
6100         return pytalloc_new(struct nbt_browse_become_backup, type);
6101 }
6102
6103
6104 static PyTypeObject nbt_browse_become_backup_Type = {
6105         PyObject_HEAD_INIT(NULL) 0,
6106         .tp_name = "nbt.browse_become_backup",
6107         .tp_getset = py_nbt_browse_become_backup_getsetters,
6108         .tp_methods = NULL,
6109         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6110         .tp_basicsize = sizeof(pytalloc_Object),
6111         .tp_new = py_nbt_browse_become_backup_new,
6112 };
6113
6114
6115 static PyObject *py_nbt_browse_domain_announcement_get_UpdateCount(PyObject *obj, void *closure)
6116 {
6117         struct nbt_browse_domain_announcement *object = (struct nbt_browse_domain_announcement *)pytalloc_get_ptr(obj);
6118         PyObject *py_UpdateCount;
6119         py_UpdateCount = PyInt_FromLong(object->UpdateCount);
6120         return py_UpdateCount;
6121 }
6122
6123 static int py_nbt_browse_domain_announcement_set_UpdateCount(PyObject *py_obj, PyObject *value, void *closure)
6124 {
6125         struct nbt_browse_domain_announcement *object = (struct nbt_browse_domain_announcement *)pytalloc_get_ptr(py_obj);
6126         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6127         object->UpdateCount = PyInt_AsLong(value);
6128         return 0;
6129 }
6130
6131 static PyObject *py_nbt_browse_domain_announcement_get_Periodicity(PyObject *obj, void *closure)
6132 {
6133         struct nbt_browse_domain_announcement *object = (struct nbt_browse_domain_announcement *)pytalloc_get_ptr(obj);
6134         PyObject *py_Periodicity;
6135         py_Periodicity = PyInt_FromLong(object->Periodicity);
6136         return py_Periodicity;
6137 }
6138
6139 static int py_nbt_browse_domain_announcement_set_Periodicity(PyObject *py_obj, PyObject *value, void *closure)
6140 {
6141         struct nbt_browse_domain_announcement *object = (struct nbt_browse_domain_announcement *)pytalloc_get_ptr(py_obj);
6142         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6143         object->Periodicity = PyInt_AsLong(value);
6144         return 0;
6145 }
6146
6147 static PyObject *py_nbt_browse_domain_announcement_get_ServerName(PyObject *obj, void *closure)
6148 {
6149         struct nbt_browse_domain_announcement *object = (struct nbt_browse_domain_announcement *)pytalloc_get_ptr(obj);
6150         PyObject *py_ServerName;
6151         if (object->ServerName == NULL) {
6152                 py_ServerName = Py_None;
6153                 Py_INCREF(py_ServerName);
6154         } else {
6155                 py_ServerName = PyUnicode_Decode(object->ServerName, strlen(object->ServerName), "utf-8", "ignore");
6156         }
6157         return py_ServerName;
6158 }
6159
6160 static int py_nbt_browse_domain_announcement_set_ServerName(PyObject *py_obj, PyObject *value, void *closure)
6161 {
6162         struct nbt_browse_domain_announcement *object = (struct nbt_browse_domain_announcement *)pytalloc_get_ptr(py_obj);
6163         if (PyUnicode_Check(value)) {
6164                 object->ServerName = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
6165         } else if (PyString_Check(value)) {
6166                 object->ServerName = PyString_AS_STRING(value);
6167         } else {
6168                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
6169                 return -1;
6170         }
6171         return 0;
6172 }
6173
6174 static PyObject *py_nbt_browse_domain_announcement_get_OSMajor(PyObject *obj, void *closure)
6175 {
6176         struct nbt_browse_domain_announcement *object = (struct nbt_browse_domain_announcement *)pytalloc_get_ptr(obj);
6177         PyObject *py_OSMajor;
6178         py_OSMajor = PyInt_FromLong(object->OSMajor);
6179         return py_OSMajor;
6180 }
6181
6182 static int py_nbt_browse_domain_announcement_set_OSMajor(PyObject *py_obj, PyObject *value, void *closure)
6183 {
6184         struct nbt_browse_domain_announcement *object = (struct nbt_browse_domain_announcement *)pytalloc_get_ptr(py_obj);
6185         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6186         object->OSMajor = PyInt_AsLong(value);
6187         return 0;
6188 }
6189
6190 static PyObject *py_nbt_browse_domain_announcement_get_OSMinor(PyObject *obj, void *closure)
6191 {
6192         struct nbt_browse_domain_announcement *object = (struct nbt_browse_domain_announcement *)pytalloc_get_ptr(obj);
6193         PyObject *py_OSMinor;
6194         py_OSMinor = PyInt_FromLong(object->OSMinor);
6195         return py_OSMinor;
6196 }
6197
6198 static int py_nbt_browse_domain_announcement_set_OSMinor(PyObject *py_obj, PyObject *value, void *closure)
6199 {
6200         struct nbt_browse_domain_announcement *object = (struct nbt_browse_domain_announcement *)pytalloc_get_ptr(py_obj);
6201         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6202         object->OSMinor = PyInt_AsLong(value);
6203         return 0;
6204 }
6205
6206 static PyObject *py_nbt_browse_domain_announcement_get_ServerType(PyObject *obj, void *closure)
6207 {
6208         struct nbt_browse_domain_announcement *object = (struct nbt_browse_domain_announcement *)pytalloc_get_ptr(obj);
6209         PyObject *py_ServerType;
6210         py_ServerType = PyInt_FromLong(object->ServerType);
6211         return py_ServerType;
6212 }
6213
6214 static int py_nbt_browse_domain_announcement_set_ServerType(PyObject *py_obj, PyObject *value, void *closure)
6215 {
6216         struct nbt_browse_domain_announcement *object = (struct nbt_browse_domain_announcement *)pytalloc_get_ptr(py_obj);
6217         if (PyLong_Check(value)) {
6218                 object->ServerType = PyLong_AsLongLong(value);
6219         } else if (PyInt_Check(value)) {
6220                 object->ServerType = PyInt_AsLong(value);
6221         } else {
6222                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
6223                   PyInt_Type.tp_name, PyLong_Type.tp_name);
6224                 return -1;
6225         }
6226         return 0;
6227 }
6228
6229 static PyObject *py_nbt_browse_domain_announcement_get_MysteriousField(PyObject *obj, void *closure)
6230 {
6231         struct nbt_browse_domain_announcement *object = (struct nbt_browse_domain_announcement *)pytalloc_get_ptr(obj);
6232         PyObject *py_MysteriousField;
6233         py_MysteriousField = PyInt_FromLong(object->MysteriousField);
6234         return py_MysteriousField;
6235 }
6236
6237 static int py_nbt_browse_domain_announcement_set_MysteriousField(PyObject *py_obj, PyObject *value, void *closure)
6238 {
6239         struct nbt_browse_domain_announcement *object = (struct nbt_browse_domain_announcement *)pytalloc_get_ptr(py_obj);
6240         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6241         object->MysteriousField = PyInt_AsLong(value);
6242         return 0;
6243 }
6244
6245 static PyObject *py_nbt_browse_domain_announcement_get_Comment(PyObject *obj, void *closure)
6246 {
6247         struct nbt_browse_domain_announcement *object = (struct nbt_browse_domain_announcement *)pytalloc_get_ptr(obj);
6248         PyObject *py_Comment;
6249         py_Comment = PyString_FromStringOrNULL(object->Comment);
6250         return py_Comment;
6251 }
6252
6253 static int py_nbt_browse_domain_announcement_set_Comment(PyObject *py_obj, PyObject *value, void *closure)
6254 {
6255         struct nbt_browse_domain_announcement *object = (struct nbt_browse_domain_announcement *)pytalloc_get_ptr(py_obj);
6256         object->Comment = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
6257         return 0;
6258 }
6259
6260 static PyGetSetDef py_nbt_browse_domain_announcement_getsetters[] = {
6261         { discard_const_p(char, "UpdateCount"), py_nbt_browse_domain_announcement_get_UpdateCount, py_nbt_browse_domain_announcement_set_UpdateCount },
6262         { discard_const_p(char, "Periodicity"), py_nbt_browse_domain_announcement_get_Periodicity, py_nbt_browse_domain_announcement_set_Periodicity },
6263         { discard_const_p(char, "ServerName"), py_nbt_browse_domain_announcement_get_ServerName, py_nbt_browse_domain_announcement_set_ServerName },
6264         { discard_const_p(char, "OSMajor"), py_nbt_browse_domain_announcement_get_OSMajor, py_nbt_browse_domain_announcement_set_OSMajor },
6265         { discard_const_p(char, "OSMinor"), py_nbt_browse_domain_announcement_get_OSMinor, py_nbt_browse_domain_announcement_set_OSMinor },
6266         { discard_const_p(char, "ServerType"), py_nbt_browse_domain_announcement_get_ServerType, py_nbt_browse_domain_announcement_set_ServerType },
6267         { discard_const_p(char, "MysteriousField"), py_nbt_browse_domain_announcement_get_MysteriousField, py_nbt_browse_domain_announcement_set_MysteriousField },
6268         { discard_const_p(char, "Comment"), py_nbt_browse_domain_announcement_get_Comment, py_nbt_browse_domain_announcement_set_Comment },
6269         { NULL }
6270 };
6271
6272 static PyObject *py_nbt_browse_domain_announcement_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
6273 {
6274         return pytalloc_new(struct nbt_browse_domain_announcement, type);
6275 }
6276
6277
6278 static PyTypeObject nbt_browse_domain_announcement_Type = {
6279         PyObject_HEAD_INIT(NULL) 0,
6280         .tp_name = "nbt.browse_domain_announcement",
6281         .tp_getset = py_nbt_browse_domain_announcement_getsetters,
6282         .tp_methods = NULL,
6283         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6284         .tp_basicsize = sizeof(pytalloc_Object),
6285         .tp_new = py_nbt_browse_domain_announcement_new,
6286 };
6287
6288
6289 static PyObject *py_nbt_browse_master_announcement_get_ServerName(PyObject *obj, void *closure)
6290 {
6291         struct nbt_browse_master_announcement *object = (struct nbt_browse_master_announcement *)pytalloc_get_ptr(obj);
6292         PyObject *py_ServerName;
6293         py_ServerName = PyString_FromStringOrNULL(object->ServerName);
6294         return py_ServerName;
6295 }
6296
6297 static int py_nbt_browse_master_announcement_set_ServerName(PyObject *py_obj, PyObject *value, void *closure)
6298 {
6299         struct nbt_browse_master_announcement *object = (struct nbt_browse_master_announcement *)pytalloc_get_ptr(py_obj);
6300         object->ServerName = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
6301         return 0;
6302 }
6303
6304 static PyGetSetDef py_nbt_browse_master_announcement_getsetters[] = {
6305         { discard_const_p(char, "ServerName"), py_nbt_browse_master_announcement_get_ServerName, py_nbt_browse_master_announcement_set_ServerName },
6306         { NULL }
6307 };
6308
6309 static PyObject *py_nbt_browse_master_announcement_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
6310 {
6311         return pytalloc_new(struct nbt_browse_master_announcement, type);
6312 }
6313
6314
6315 static PyTypeObject nbt_browse_master_announcement_Type = {
6316         PyObject_HEAD_INIT(NULL) 0,
6317         .tp_name = "nbt.browse_master_announcement",
6318         .tp_getset = py_nbt_browse_master_announcement_getsetters,
6319         .tp_methods = NULL,
6320         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6321         .tp_basicsize = sizeof(pytalloc_Object),
6322         .tp_new = py_nbt_browse_master_announcement_new,
6323 };
6324
6325
6326 static PyObject *py_nbt_browse_reset_state_get_Command(PyObject *obj, void *closure)
6327 {
6328         struct nbt_browse_reset_state *object = (struct nbt_browse_reset_state *)pytalloc_get_ptr(obj);
6329         PyObject *py_Command;
6330         py_Command = PyInt_FromLong(object->Command);
6331         return py_Command;
6332 }
6333
6334 static int py_nbt_browse_reset_state_set_Command(PyObject *py_obj, PyObject *value, void *closure)
6335 {
6336         struct nbt_browse_reset_state *object = (struct nbt_browse_reset_state *)pytalloc_get_ptr(py_obj);
6337         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6338         object->Command = PyInt_AsLong(value);
6339         return 0;
6340 }
6341
6342 static PyGetSetDef py_nbt_browse_reset_state_getsetters[] = {
6343         { discard_const_p(char, "Command"), py_nbt_browse_reset_state_get_Command, py_nbt_browse_reset_state_set_Command },
6344         { NULL }
6345 };
6346
6347 static PyObject *py_nbt_browse_reset_state_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
6348 {
6349         return pytalloc_new(struct nbt_browse_reset_state, type);
6350 }
6351
6352
6353 static PyTypeObject nbt_browse_reset_state_Type = {
6354         PyObject_HEAD_INIT(NULL) 0,
6355         .tp_name = "nbt.browse_reset_state",
6356         .tp_getset = py_nbt_browse_reset_state_getsetters,
6357         .tp_methods = NULL,
6358         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6359         .tp_basicsize = sizeof(pytalloc_Object),
6360         .tp_new = py_nbt_browse_reset_state_new,
6361 };
6362
6363
6364 static PyObject *py_nbt_browse_local_master_announcement_get_UpdateCount(PyObject *obj, void *closure)
6365 {
6366         struct nbt_browse_local_master_announcement *object = (struct nbt_browse_local_master_announcement *)pytalloc_get_ptr(obj);
6367         PyObject *py_UpdateCount;
6368         py_UpdateCount = PyInt_FromLong(object->UpdateCount);
6369         return py_UpdateCount;
6370 }
6371
6372 static int py_nbt_browse_local_master_announcement_set_UpdateCount(PyObject *py_obj, PyObject *value, void *closure)
6373 {
6374         struct nbt_browse_local_master_announcement *object = (struct nbt_browse_local_master_announcement *)pytalloc_get_ptr(py_obj);
6375         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6376         object->UpdateCount = PyInt_AsLong(value);
6377         return 0;
6378 }
6379
6380 static PyObject *py_nbt_browse_local_master_announcement_get_Periodicity(PyObject *obj, void *closure)
6381 {
6382         struct nbt_browse_local_master_announcement *object = (struct nbt_browse_local_master_announcement *)pytalloc_get_ptr(obj);
6383         PyObject *py_Periodicity;
6384         py_Periodicity = PyInt_FromLong(object->Periodicity);
6385         return py_Periodicity;
6386 }
6387
6388 static int py_nbt_browse_local_master_announcement_set_Periodicity(PyObject *py_obj, PyObject *value, void *closure)
6389 {
6390         struct nbt_browse_local_master_announcement *object = (struct nbt_browse_local_master_announcement *)pytalloc_get_ptr(py_obj);
6391         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6392         object->Periodicity = PyInt_AsLong(value);
6393         return 0;
6394 }
6395
6396 static PyObject *py_nbt_browse_local_master_announcement_get_ServerName(PyObject *obj, void *closure)
6397 {
6398         struct nbt_browse_local_master_announcement *object = (struct nbt_browse_local_master_announcement *)pytalloc_get_ptr(obj);
6399         PyObject *py_ServerName;
6400         if (object->ServerName == NULL) {
6401                 py_ServerName = Py_None;
6402                 Py_INCREF(py_ServerName);
6403         } else {
6404                 py_ServerName = PyUnicode_Decode(object->ServerName, strlen(object->ServerName), "utf-8", "ignore");
6405         }
6406         return py_ServerName;
6407 }
6408
6409 static int py_nbt_browse_local_master_announcement_set_ServerName(PyObject *py_obj, PyObject *value, void *closure)
6410 {
6411         struct nbt_browse_local_master_announcement *object = (struct nbt_browse_local_master_announcement *)pytalloc_get_ptr(py_obj);
6412         if (PyUnicode_Check(value)) {
6413                 object->ServerName = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
6414         } else if (PyString_Check(value)) {
6415                 object->ServerName = PyString_AS_STRING(value);
6416         } else {
6417                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
6418                 return -1;
6419         }
6420         return 0;
6421 }
6422
6423 static PyObject *py_nbt_browse_local_master_announcement_get_OSMajor(PyObject *obj, void *closure)
6424 {
6425         struct nbt_browse_local_master_announcement *object = (struct nbt_browse_local_master_announcement *)pytalloc_get_ptr(obj);
6426         PyObject *py_OSMajor;
6427         py_OSMajor = PyInt_FromLong(object->OSMajor);
6428         return py_OSMajor;
6429 }
6430
6431 static int py_nbt_browse_local_master_announcement_set_OSMajor(PyObject *py_obj, PyObject *value, void *closure)
6432 {
6433         struct nbt_browse_local_master_announcement *object = (struct nbt_browse_local_master_announcement *)pytalloc_get_ptr(py_obj);
6434         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6435         object->OSMajor = PyInt_AsLong(value);
6436         return 0;
6437 }
6438
6439 static PyObject *py_nbt_browse_local_master_announcement_get_OSMinor(PyObject *obj, void *closure)
6440 {
6441         struct nbt_browse_local_master_announcement *object = (struct nbt_browse_local_master_announcement *)pytalloc_get_ptr(obj);
6442         PyObject *py_OSMinor;
6443         py_OSMinor = PyInt_FromLong(object->OSMinor);
6444         return py_OSMinor;
6445 }
6446
6447 static int py_nbt_browse_local_master_announcement_set_OSMinor(PyObject *py_obj, PyObject *value, void *closure)
6448 {
6449         struct nbt_browse_local_master_announcement *object = (struct nbt_browse_local_master_announcement *)pytalloc_get_ptr(py_obj);
6450         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6451         object->OSMinor = PyInt_AsLong(value);
6452         return 0;
6453 }
6454
6455 static PyObject *py_nbt_browse_local_master_announcement_get_ServerType(PyObject *obj, void *closure)
6456 {
6457         struct nbt_browse_local_master_announcement *object = (struct nbt_browse_local_master_announcement *)pytalloc_get_ptr(obj);
6458         PyObject *py_ServerType;
6459         py_ServerType = PyInt_FromLong(object->ServerType);
6460         return py_ServerType;
6461 }
6462
6463 static int py_nbt_browse_local_master_announcement_set_ServerType(PyObject *py_obj, PyObject *value, void *closure)
6464 {
6465         struct nbt_browse_local_master_announcement *object = (struct nbt_browse_local_master_announcement *)pytalloc_get_ptr(py_obj);
6466         if (PyLong_Check(value)) {
6467                 object->ServerType = PyLong_AsLongLong(value);
6468         } else if (PyInt_Check(value)) {
6469                 object->ServerType = PyInt_AsLong(value);
6470         } else {
6471                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
6472                   PyInt_Type.tp_name, PyLong_Type.tp_name);
6473                 return -1;
6474         }
6475         return 0;
6476 }
6477
6478 static PyObject *py_nbt_browse_local_master_announcement_get_BroMajorVer(PyObject *obj, void *closure)
6479 {
6480         struct nbt_browse_local_master_announcement *object = (struct nbt_browse_local_master_announcement *)pytalloc_get_ptr(obj);
6481         PyObject *py_BroMajorVer;
6482         py_BroMajorVer = PyInt_FromLong(object->BroMajorVer);
6483         return py_BroMajorVer;
6484 }
6485
6486 static int py_nbt_browse_local_master_announcement_set_BroMajorVer(PyObject *py_obj, PyObject *value, void *closure)
6487 {
6488         struct nbt_browse_local_master_announcement *object = (struct nbt_browse_local_master_announcement *)pytalloc_get_ptr(py_obj);
6489         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6490         object->BroMajorVer = PyInt_AsLong(value);
6491         return 0;
6492 }
6493
6494 static PyObject *py_nbt_browse_local_master_announcement_get_BroMinorVer(PyObject *obj, void *closure)
6495 {
6496         struct nbt_browse_local_master_announcement *object = (struct nbt_browse_local_master_announcement *)pytalloc_get_ptr(obj);
6497         PyObject *py_BroMinorVer;
6498         py_BroMinorVer = PyInt_FromLong(object->BroMinorVer);
6499         return py_BroMinorVer;
6500 }
6501
6502 static int py_nbt_browse_local_master_announcement_set_BroMinorVer(PyObject *py_obj, PyObject *value, void *closure)
6503 {
6504         struct nbt_browse_local_master_announcement *object = (struct nbt_browse_local_master_announcement *)pytalloc_get_ptr(py_obj);
6505         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6506         object->BroMinorVer = PyInt_AsLong(value);
6507         return 0;
6508 }
6509
6510 static PyObject *py_nbt_browse_local_master_announcement_get_Signature(PyObject *obj, void *closure)
6511 {
6512         struct nbt_browse_local_master_announcement *object = (struct nbt_browse_local_master_announcement *)pytalloc_get_ptr(obj);
6513         PyObject *py_Signature;
6514         py_Signature = PyInt_FromLong(object->Signature);
6515         return py_Signature;
6516 }
6517
6518 static int py_nbt_browse_local_master_announcement_set_Signature(PyObject *py_obj, PyObject *value, void *closure)
6519 {
6520         struct nbt_browse_local_master_announcement *object = (struct nbt_browse_local_master_announcement *)pytalloc_get_ptr(py_obj);
6521         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
6522         object->Signature = PyInt_AsLong(value);
6523         return 0;
6524 }
6525
6526 static PyObject *py_nbt_browse_local_master_announcement_get_Comment(PyObject *obj, void *closure)
6527 {
6528         struct nbt_browse_local_master_announcement *object = (struct nbt_browse_local_master_announcement *)pytalloc_get_ptr(obj);
6529         PyObject *py_Comment;
6530         py_Comment = PyString_FromStringOrNULL(object->Comment);
6531         return py_Comment;
6532 }
6533
6534 static int py_nbt_browse_local_master_announcement_set_Comment(PyObject *py_obj, PyObject *value, void *closure)
6535 {
6536         struct nbt_browse_local_master_announcement *object = (struct nbt_browse_local_master_announcement *)pytalloc_get_ptr(py_obj);
6537         object->Comment = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
6538         return 0;
6539 }
6540
6541 static PyGetSetDef py_nbt_browse_local_master_announcement_getsetters[] = {
6542         { discard_const_p(char, "UpdateCount"), py_nbt_browse_local_master_announcement_get_UpdateCount, py_nbt_browse_local_master_announcement_set_UpdateCount },
6543         { discard_const_p(char, "Periodicity"), py_nbt_browse_local_master_announcement_get_Periodicity, py_nbt_browse_local_master_announcement_set_Periodicity },
6544         { discard_const_p(char, "ServerName"), py_nbt_browse_local_master_announcement_get_ServerName, py_nbt_browse_local_master_announcement_set_ServerName },
6545         { discard_const_p(char, "OSMajor"), py_nbt_browse_local_master_announcement_get_OSMajor, py_nbt_browse_local_master_announcement_set_OSMajor },
6546         { discard_const_p(char, "OSMinor"), py_nbt_browse_local_master_announcement_get_OSMinor, py_nbt_browse_local_master_announcement_set_OSMinor },
6547         { discard_const_p(char, "ServerType"), py_nbt_browse_local_master_announcement_get_ServerType, py_nbt_browse_local_master_announcement_set_ServerType },
6548         { discard_const_p(char, "BroMajorVer"), py_nbt_browse_local_master_announcement_get_BroMajorVer, py_nbt_browse_local_master_announcement_set_BroMajorVer },
6549         { discard_const_p(char, "BroMinorVer"), py_nbt_browse_local_master_announcement_get_BroMinorVer, py_nbt_browse_local_master_announcement_set_BroMinorVer },
6550         { discard_const_p(char, "Signature"), py_nbt_browse_local_master_announcement_get_Signature, py_nbt_browse_local_master_announcement_set_Signature },
6551         { discard_const_p(char, "Comment"), py_nbt_browse_local_master_announcement_get_Comment, py_nbt_browse_local_master_announcement_set_Comment },
6552         { NULL }
6553 };
6554
6555 static PyObject *py_nbt_browse_local_master_announcement_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
6556 {
6557         return pytalloc_new(struct nbt_browse_local_master_announcement, type);
6558 }
6559
6560
6561 static PyTypeObject nbt_browse_local_master_announcement_Type = {
6562         PyObject_HEAD_INIT(NULL) 0,
6563         .tp_name = "nbt.browse_local_master_announcement",
6564         .tp_getset = py_nbt_browse_local_master_announcement_getsetters,
6565         .tp_methods = NULL,
6566         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6567         .tp_basicsize = sizeof(pytalloc_Object),
6568         .tp_new = py_nbt_browse_local_master_announcement_new,
6569 };
6570
6571 PyObject *py_import_nbt_browse_payload(TALLOC_CTX *mem_ctx, int level, union nbt_browse_payload *in)
6572 {
6573         PyObject *ret;
6574
6575         switch (level) {
6576                 case HostAnnouncement:
6577                         ret = pytalloc_reference_ex(&nbt_browse_host_announcement_Type, mem_ctx, &in->host_annoucement);
6578                         return ret;
6579
6580                 case AnnouncementRequest:
6581                         ret = pytalloc_reference_ex(&nbt_browse_announcement_request_Type, mem_ctx, &in->announcement_request);
6582                         return ret;
6583
6584                 case Election:
6585                         ret = pytalloc_reference_ex(&nbt_browse_election_request_Type, mem_ctx, &in->election_request);
6586                         return ret;
6587
6588                 case GetBackupListReq:
6589                         ret = pytalloc_reference_ex(&nbt_browse_backup_list_request_Type, mem_ctx, &in->backup_list_request);
6590                         return ret;
6591
6592                 case GetBackupListResp:
6593                         ret = pytalloc_reference_ex(&nbt_browse_backup_list_response_Type, mem_ctx, &in->backup_list_response);
6594                         return ret;
6595
6596                 case BecomeBackup:
6597                         ret = pytalloc_reference_ex(&nbt_browse_become_backup_Type, mem_ctx, &in->become_backup);
6598                         return ret;
6599
6600                 case DomainAnnouncement:
6601                         ret = pytalloc_reference_ex(&nbt_browse_domain_announcement_Type, mem_ctx, &in->domain_announcement);
6602                         return ret;
6603
6604                 case MasterAnnouncement:
6605                         ret = pytalloc_reference_ex(&nbt_browse_master_announcement_Type, mem_ctx, &in->master_announcement);
6606                         return ret;
6607
6608                 case ResetBrowserState:
6609                         ret = pytalloc_reference_ex(&nbt_browse_reset_state_Type, mem_ctx, &in->reset_browser_state);
6610                         return ret;
6611
6612                 case LocalMasterAnnouncement:
6613                         ret = pytalloc_reference_ex(&nbt_browse_local_master_announcement_Type, mem_ctx, &in->local_master_announcement);
6614                         return ret;
6615
6616         }
6617         PyErr_SetString(PyExc_TypeError, "unknown union level");
6618         return NULL;
6619 }
6620
6621 union nbt_browse_payload *py_export_nbt_browse_payload(TALLOC_CTX *mem_ctx, int level, PyObject *in)
6622 {
6623         union nbt_browse_payload *ret = talloc_zero(mem_ctx, union nbt_browse_payload);
6624         switch (level) {
6625                 case HostAnnouncement:
6626                         PY_CHECK_TYPE(&nbt_browse_host_announcement_Type, in, talloc_free(ret); return NULL;);
6627                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6628                                 PyErr_NoMemory();
6629                                 talloc_free(ret); return NULL;
6630                         }
6631                         ret->host_annoucement = *(struct nbt_browse_host_announcement *)pytalloc_get_ptr(in);
6632                         break;
6633
6634                 case AnnouncementRequest:
6635                         PY_CHECK_TYPE(&nbt_browse_announcement_request_Type, in, talloc_free(ret); return NULL;);
6636                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6637                                 PyErr_NoMemory();
6638                                 talloc_free(ret); return NULL;
6639                         }
6640                         ret->announcement_request = *(struct nbt_browse_announcement_request *)pytalloc_get_ptr(in);
6641                         break;
6642
6643                 case Election:
6644                         PY_CHECK_TYPE(&nbt_browse_election_request_Type, in, talloc_free(ret); return NULL;);
6645                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6646                                 PyErr_NoMemory();
6647                                 talloc_free(ret); return NULL;
6648                         }
6649                         ret->election_request = *(struct nbt_browse_election_request *)pytalloc_get_ptr(in);
6650                         break;
6651
6652                 case GetBackupListReq:
6653                         PY_CHECK_TYPE(&nbt_browse_backup_list_request_Type, in, talloc_free(ret); return NULL;);
6654                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6655                                 PyErr_NoMemory();
6656                                 talloc_free(ret); return NULL;
6657                         }
6658                         ret->backup_list_request = *(struct nbt_browse_backup_list_request *)pytalloc_get_ptr(in);
6659                         break;
6660
6661                 case GetBackupListResp:
6662                         PY_CHECK_TYPE(&nbt_browse_backup_list_response_Type, in, talloc_free(ret); return NULL;);
6663                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6664                                 PyErr_NoMemory();
6665                                 talloc_free(ret); return NULL;
6666                         }
6667                         ret->backup_list_response = *(struct nbt_browse_backup_list_response *)pytalloc_get_ptr(in);
6668                         break;
6669
6670                 case BecomeBackup:
6671                         PY_CHECK_TYPE(&nbt_browse_become_backup_Type, in, talloc_free(ret); return NULL;);
6672                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6673                                 PyErr_NoMemory();
6674                                 talloc_free(ret); return NULL;
6675                         }
6676                         ret->become_backup = *(struct nbt_browse_become_backup *)pytalloc_get_ptr(in);
6677                         break;
6678
6679                 case DomainAnnouncement:
6680                         PY_CHECK_TYPE(&nbt_browse_domain_announcement_Type, in, talloc_free(ret); return NULL;);
6681                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6682                                 PyErr_NoMemory();
6683                                 talloc_free(ret); return NULL;
6684                         }
6685                         ret->domain_announcement = *(struct nbt_browse_domain_announcement *)pytalloc_get_ptr(in);
6686                         break;
6687
6688                 case MasterAnnouncement:
6689                         PY_CHECK_TYPE(&nbt_browse_master_announcement_Type, in, talloc_free(ret); return NULL;);
6690                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6691                                 PyErr_NoMemory();
6692                                 talloc_free(ret); return NULL;
6693                         }
6694                         ret->master_announcement = *(struct nbt_browse_master_announcement *)pytalloc_get_ptr(in);
6695                         break;
6696
6697                 case ResetBrowserState:
6698                         PY_CHECK_TYPE(&nbt_browse_reset_state_Type, in, talloc_free(ret); return NULL;);
6699                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6700                                 PyErr_NoMemory();
6701                                 talloc_free(ret); return NULL;
6702                         }
6703                         ret->reset_browser_state = *(struct nbt_browse_reset_state *)pytalloc_get_ptr(in);
6704                         break;
6705
6706                 case LocalMasterAnnouncement:
6707                         PY_CHECK_TYPE(&nbt_browse_local_master_announcement_Type, in, talloc_free(ret); return NULL;);
6708                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
6709                                 PyErr_NoMemory();
6710                                 talloc_free(ret); return NULL;
6711                         }
6712                         ret->local_master_announcement = *(struct nbt_browse_local_master_announcement *)pytalloc_get_ptr(in);
6713                         break;
6714
6715                 default:
6716                         PyErr_SetString(PyExc_TypeError, "invalid union level value");
6717                         talloc_free(ret);
6718                         ret = NULL;
6719         }
6720
6721         return ret;
6722 }
6723
6724
6725 static PyObject *py_nbt_browse_packet_get_opcode(PyObject *obj, void *closure)
6726 {
6727         struct nbt_browse_packet *object = (struct nbt_browse_packet *)pytalloc_get_ptr(obj);
6728         PyObject *py_opcode;
6729         py_opcode = PyInt_FromLong(object->opcode);
6730         return py_opcode;
6731 }
6732
6733 static int py_nbt_browse_packet_set_opcode(PyObject *py_obj, PyObject *value, void *closure)
6734 {
6735         struct nbt_browse_packet *object = (struct nbt_browse_packet *)pytalloc_get_ptr(py_obj);
6736         if (PyLong_Check(value)) {
6737                 object->opcode = PyLong_AsLongLong(value);
6738         } else if (PyInt_Check(value)) {
6739                 object->opcode = PyInt_AsLong(value);
6740         } else {
6741                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
6742                   PyInt_Type.tp_name, PyLong_Type.tp_name);
6743                 return -1;
6744         }
6745         return 0;
6746 }
6747
6748 static PyObject *py_nbt_browse_packet_get_payload(PyObject *obj, void *closure)
6749 {
6750         struct nbt_browse_packet *object = (struct nbt_browse_packet *)pytalloc_get_ptr(obj);
6751         PyObject *py_payload;
6752         py_payload = py_import_nbt_browse_payload(pytalloc_get_mem_ctx(obj), object->opcode, &object->payload);
6753         if (py_payload == NULL) {
6754                 return NULL;
6755         }
6756         return py_payload;
6757 }
6758
6759 static int py_nbt_browse_packet_set_payload(PyObject *py_obj, PyObject *value, void *closure)
6760 {
6761         struct nbt_browse_packet *object = (struct nbt_browse_packet *)pytalloc_get_ptr(py_obj);
6762         {
6763                 union nbt_browse_payload *payload_switch_0;
6764                 payload_switch_0 = py_export_nbt_browse_payload(pytalloc_get_mem_ctx(py_obj), object->opcode, value);
6765                 if (payload_switch_0 == NULL) {
6766                         return -1;
6767                 }
6768                 object->payload = *payload_switch_0;
6769         }
6770         return 0;
6771 }
6772
6773 static PyGetSetDef py_nbt_browse_packet_getsetters[] = {
6774         { discard_const_p(char, "opcode"), py_nbt_browse_packet_get_opcode, py_nbt_browse_packet_set_opcode },
6775         { discard_const_p(char, "payload"), py_nbt_browse_packet_get_payload, py_nbt_browse_packet_set_payload },
6776         { NULL }
6777 };
6778
6779 static PyObject *py_nbt_browse_packet_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
6780 {
6781         return pytalloc_new(struct nbt_browse_packet, type);
6782 }
6783
6784 static PyObject *py_nbt_browse_packet_ndr_pack(PyObject *py_obj)
6785 {
6786         struct nbt_browse_packet *object = (struct nbt_browse_packet *)pytalloc_get_ptr(py_obj);
6787         DATA_BLOB blob;
6788         enum ndr_err_code err;
6789         err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_nbt_browse_packet);
6790         if (err != NDR_ERR_SUCCESS) {
6791                 PyErr_SetNdrError(err);
6792                 return NULL;
6793         }
6794
6795         return PyString_FromStringAndSize((char *)blob.data, blob.length);
6796 }
6797
6798 static PyObject *py_nbt_browse_packet_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
6799 {
6800         struct nbt_browse_packet *object = (struct nbt_browse_packet *)pytalloc_get_ptr(py_obj);
6801         DATA_BLOB blob;
6802         int blob_length = 0;
6803         enum ndr_err_code err;
6804         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
6805         PyObject *allow_remaining_obj = NULL;
6806         bool allow_remaining = false;
6807
6808         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
6809                 discard_const_p(char *, kwnames),
6810                 &blob.data, &blob_length,
6811                 &allow_remaining_obj)) {
6812                 return NULL;
6813         }
6814         blob.length = blob_length;
6815
6816         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
6817                 allow_remaining = true;
6818         }
6819
6820         if (allow_remaining) {
6821                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_nbt_browse_packet);
6822         } else {
6823                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_nbt_browse_packet);
6824         }
6825         if (err != NDR_ERR_SUCCESS) {
6826                 PyErr_SetNdrError(err);
6827                 return NULL;
6828         }
6829
6830         Py_RETURN_NONE;
6831 }
6832
6833 static PyObject *py_nbt_browse_packet_ndr_print(PyObject *py_obj)
6834 {
6835         struct nbt_browse_packet *object = (struct nbt_browse_packet *)pytalloc_get_ptr(py_obj);
6836         PyObject *ret;
6837         char *retstr;
6838
6839         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_nbt_browse_packet, "nbt_browse_packet", object);
6840         ret = PyString_FromString(retstr);
6841         talloc_free(retstr);
6842
6843         return ret;
6844 }
6845
6846 static PyMethodDef py_nbt_browse_packet_methods[] = {
6847         { "__ndr_pack__", (PyCFunction)py_nbt_browse_packet_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
6848         { "__ndr_unpack__", (PyCFunction)py_nbt_browse_packet_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
6849         { "__ndr_print__", (PyCFunction)py_nbt_browse_packet_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
6850         { NULL, NULL, 0, NULL }
6851 };
6852
6853
6854 static PyTypeObject nbt_browse_packet_Type = {
6855         PyObject_HEAD_INIT(NULL) 0,
6856         .tp_name = "nbt.browse_packet",
6857         .tp_getset = py_nbt_browse_packet_getsetters,
6858         .tp_methods = py_nbt_browse_packet_methods,
6859         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6860         .tp_basicsize = sizeof(pytalloc_Object),
6861         .tp_new = py_nbt_browse_packet_new,
6862 };
6863
6864
6865 static bool pack_py_decode_nbt_netlogon_packet_args_in(PyObject *args, PyObject *kwargs, struct decode_nbt_netlogon_packet *r)
6866 {
6867         PyObject *py_packet;
6868         const char *kwnames[] = {
6869                 "packet", NULL
6870         };
6871
6872         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:decode_nbt_netlogon_packet", discard_const_p(char *, kwnames), &py_packet)) {
6873                 return false;
6874         }
6875
6876         PY_CHECK_TYPE(&nbt_netlogon_packet_Type, py_packet, return false;);
6877         if (talloc_reference(r, pytalloc_get_mem_ctx(py_packet)) == NULL) {
6878                 PyErr_NoMemory();
6879                 return false;
6880         }
6881         r->in.packet = *(struct nbt_netlogon_packet *)pytalloc_get_ptr(py_packet);
6882         return true;
6883 }
6884
6885 static PyObject *unpack_py_decode_nbt_netlogon_packet_args_out(struct decode_nbt_netlogon_packet *r)
6886 {
6887         PyObject *result;
6888         result = Py_None;
6889         Py_INCREF(result);
6890         return result;
6891 }
6892
6893 const struct PyNdrRpcMethodDef py_ndr_nbt_methods[] = {
6894         { "decode_nbt_netlogon_packet", "S.decode_nbt_netlogon_packet(packet) -> None", (py_dcerpc_call_fn)dcerpc_decode_nbt_netlogon_packet_r, (py_data_pack_fn)pack_py_decode_nbt_netlogon_packet_args_in, (py_data_unpack_fn)unpack_py_decode_nbt_netlogon_packet_args_out, 0, &ndr_table_nbt },
6895         { NULL }
6896 };
6897
6898 static PyObject *interface_nbt_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
6899 {
6900         return py_dcerpc_interface_init_helper(type, args, kwargs, &ndr_table_nbt);
6901 }
6902
6903 #define PY_DOC_NBT "NBT messages"
6904 static PyTypeObject nbt_InterfaceType = {
6905         PyObject_HEAD_INIT(NULL) 0,
6906         .tp_name = "nbt.nbt",
6907         .tp_basicsize = sizeof(dcerpc_InterfaceObject),
6908         .tp_doc = "nbt(binding, lp_ctx=None, credentials=None) -> connection\n"
6909 "\n"
6910 "binding should be a DCE/RPC binding string (for example: ncacn_ip_tcp:127.0.0.1)\n"
6911 "lp_ctx should be a path to a smb.conf file or a param.LoadParm object\n"
6912 "credentials should be a credentials.Credentials object.\n\n"PY_DOC_NBT,
6913         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6914         .tp_new = interface_nbt_new,
6915 };
6916
6917 static PyMethodDef nbt_methods[] = {
6918         { NULL, NULL, 0, NULL }
6919 };
6920
6921 void initnbt(void)
6922 {
6923         PyObject *m;
6924         PyObject *dep_samba_dcerpc_security;
6925         PyObject *dep_talloc;
6926         PyObject *dep_samba_dcerpc_misc;
6927         PyObject *dep_samba_dcerpc_base;
6928
6929         dep_samba_dcerpc_security = PyImport_ImportModule("samba.dcerpc.security");
6930         if (dep_samba_dcerpc_security == NULL)
6931                 return;
6932
6933         dep_talloc = PyImport_ImportModule("talloc");
6934         if (dep_talloc == NULL)
6935                 return;
6936
6937         dep_samba_dcerpc_misc = PyImport_ImportModule("samba.dcerpc.misc");
6938         if (dep_samba_dcerpc_misc == NULL)
6939                 return;
6940
6941         dep_samba_dcerpc_base = PyImport_ImportModule("samba.dcerpc.base");
6942         if (dep_samba_dcerpc_base == NULL)
6943                 return;
6944
6945         dom_sid_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_security, "dom_sid");
6946         if (dom_sid_Type == NULL)
6947                 return;
6948
6949         Object_Type = (PyTypeObject *)PyObject_GetAttrString(dep_talloc, "Object");
6950         if (Object_Type == NULL)
6951                 return;
6952
6953         GUID_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_misc, "GUID");
6954         if (GUID_Type == NULL)
6955                 return;
6956
6957         ClientConnection_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_base, "ClientConnection");
6958         if (ClientConnection_Type == NULL)
6959                 return;
6960
6961         nbt_name_Type.tp_base = Object_Type;
6962
6963         nbt_name_question_Type.tp_base = Object_Type;
6964
6965         nbt_rdata_address_Type.tp_base = Object_Type;
6966
6967         nbt_rdata_netbios_Type.tp_base = Object_Type;
6968
6969         nbt_statistics_Type.tp_base = Object_Type;
6970
6971         nbt_status_name_Type.tp_base = Object_Type;
6972
6973         nbt_rdata_status_Type.tp_base = Object_Type;
6974
6975         nbt_rdata_data_Type.tp_base = Object_Type;
6976
6977         nbt_res_rec_Type.tp_base = Object_Type;
6978
6979         nbt_name_packet_Type.tp_base = Object_Type;
6980
6981         smb_trans_body_Type.tp_base = Object_Type;
6982
6983         dgram_smb_packet_Type.tp_base = Object_Type;
6984
6985         dgram_message_Type.tp_base = Object_Type;
6986
6987         nbt_dgram_packet_Type.tp_base = Object_Type;
6988
6989         nbt_sockaddr_Type.tp_base = Object_Type;
6990
6991         NETLOGON_SAM_LOGON_REQUEST_Type.tp_base = Object_Type;
6992
6993         NETLOGON_LOGON_REQUEST_Type.tp_base = Object_Type;
6994
6995         NETLOGON_SAM_LOGON_RESPONSE_NT40_Type.tp_base = Object_Type;
6996
6997         NETLOGON_SAM_LOGON_RESPONSE_Type.tp_base = Object_Type;
6998
6999         NETLOGON_SAM_LOGON_RESPONSE_EX_Type.tp_base = Object_Type;
7000
7001         nbt_netlogon_query_for_pdc_Type.tp_base = Object_Type;
7002
7003         nbt_netlogon_response_from_pdc_Type.tp_base = Object_Type;
7004
7005         nbt_netlogon_response2_Type.tp_base = Object_Type;
7006
7007         nbt_db_change_info_Type.tp_base = Object_Type;
7008
7009         NETLOGON_DB_CHANGE_Type.tp_base = Object_Type;
7010
7011         nbt_netlogon_packet_Type.tp_base = Object_Type;
7012
7013         nbt_browse_host_announcement_Type.tp_base = Object_Type;
7014
7015         nbt_browse_announcement_request_Type.tp_base = Object_Type;
7016
7017         nbt_browse_election_request_Type.tp_base = Object_Type;
7018
7019         nbt_browse_backup_list_request_Type.tp_base = Object_Type;
7020
7021         nbt_browse_backup_list_response_Type.tp_base = Object_Type;
7022
7023         nbt_browse_become_backup_Type.tp_base = Object_Type;
7024
7025         nbt_browse_domain_announcement_Type.tp_base = Object_Type;
7026
7027         nbt_browse_master_announcement_Type.tp_base = Object_Type;
7028
7029         nbt_browse_reset_state_Type.tp_base = Object_Type;
7030
7031         nbt_browse_local_master_announcement_Type.tp_base = Object_Type;
7032
7033         nbt_browse_packet_Type.tp_base = Object_Type;
7034
7035         nbt_InterfaceType.tp_base = ClientConnection_Type;
7036
7037         if (PyType_Ready(&nbt_name_Type) < 0)
7038                 return;
7039         if (PyType_Ready(&nbt_name_question_Type) < 0)
7040                 return;
7041         if (PyType_Ready(&nbt_rdata_address_Type) < 0)
7042                 return;
7043         if (PyType_Ready(&nbt_rdata_netbios_Type) < 0)
7044                 return;
7045         if (PyType_Ready(&nbt_statistics_Type) < 0)
7046                 return;
7047         if (PyType_Ready(&nbt_status_name_Type) < 0)
7048                 return;
7049         if (PyType_Ready(&nbt_rdata_status_Type) < 0)
7050                 return;
7051         if (PyType_Ready(&nbt_rdata_data_Type) < 0)
7052                 return;
7053         if (PyType_Ready(&nbt_res_rec_Type) < 0)
7054                 return;
7055         if (PyType_Ready(&nbt_name_packet_Type) < 0)
7056                 return;
7057         if (PyType_Ready(&smb_trans_body_Type) < 0)
7058                 return;
7059         if (PyType_Ready(&dgram_smb_packet_Type) < 0)
7060                 return;
7061         if (PyType_Ready(&dgram_message_Type) < 0)
7062                 return;
7063         if (PyType_Ready(&nbt_dgram_packet_Type) < 0)
7064                 return;
7065         if (PyType_Ready(&nbt_sockaddr_Type) < 0)
7066                 return;
7067         if (PyType_Ready(&NETLOGON_SAM_LOGON_REQUEST_Type) < 0)
7068                 return;
7069         if (PyType_Ready(&NETLOGON_LOGON_REQUEST_Type) < 0)
7070                 return;
7071         if (PyType_Ready(&NETLOGON_SAM_LOGON_RESPONSE_NT40_Type) < 0)
7072                 return;
7073         if (PyType_Ready(&NETLOGON_SAM_LOGON_RESPONSE_Type) < 0)
7074                 return;
7075         if (PyType_Ready(&NETLOGON_SAM_LOGON_RESPONSE_EX_Type) < 0)
7076                 return;
7077         if (PyType_Ready(&nbt_netlogon_query_for_pdc_Type) < 0)
7078                 return;
7079         if (PyType_Ready(&nbt_netlogon_response_from_pdc_Type) < 0)
7080                 return;
7081         if (PyType_Ready(&nbt_netlogon_response2_Type) < 0)
7082                 return;
7083         if (PyType_Ready(&nbt_db_change_info_Type) < 0)
7084                 return;
7085         if (PyType_Ready(&NETLOGON_DB_CHANGE_Type) < 0)
7086                 return;
7087         if (PyType_Ready(&nbt_netlogon_packet_Type) < 0)
7088                 return;
7089         if (PyType_Ready(&nbt_browse_host_announcement_Type) < 0)
7090                 return;
7091         if (PyType_Ready(&nbt_browse_announcement_request_Type) < 0)
7092                 return;
7093         if (PyType_Ready(&nbt_browse_election_request_Type) < 0)
7094                 return;
7095         if (PyType_Ready(&nbt_browse_backup_list_request_Type) < 0)
7096                 return;
7097         if (PyType_Ready(&nbt_browse_backup_list_response_Type) < 0)
7098                 return;
7099         if (PyType_Ready(&nbt_browse_become_backup_Type) < 0)
7100                 return;
7101         if (PyType_Ready(&nbt_browse_domain_announcement_Type) < 0)
7102                 return;
7103         if (PyType_Ready(&nbt_browse_master_announcement_Type) < 0)
7104                 return;
7105         if (PyType_Ready(&nbt_browse_reset_state_Type) < 0)
7106                 return;
7107         if (PyType_Ready(&nbt_browse_local_master_announcement_Type) < 0)
7108                 return;
7109         if (PyType_Ready(&nbt_browse_packet_Type) < 0)
7110                 return;
7111         if (PyType_Ready(&nbt_InterfaceType) < 0)
7112                 return;
7113         if (!PyInterface_AddNdrRpcMethods(&nbt_InterfaceType, py_ndr_nbt_methods))
7114                 return;
7115
7116 #ifdef PY_NAME_PATCH
7117         PY_NAME_PATCH(&nbt_name_Type);
7118 #endif
7119 #ifdef PY_NAME_QUESTION_PATCH
7120         PY_NAME_QUESTION_PATCH(&nbt_name_question_Type);
7121 #endif
7122 #ifdef PY_RDATA_ADDRESS_PATCH
7123         PY_RDATA_ADDRESS_PATCH(&nbt_rdata_address_Type);
7124 #endif
7125 #ifdef PY_RDATA_NETBIOS_PATCH
7126         PY_RDATA_NETBIOS_PATCH(&nbt_rdata_netbios_Type);
7127 #endif
7128 #ifdef PY_STATISTICS_PATCH
7129         PY_STATISTICS_PATCH(&nbt_statistics_Type);
7130 #endif
7131 #ifdef PY_STATUS_NAME_PATCH
7132         PY_STATUS_NAME_PATCH(&nbt_status_name_Type);
7133 #endif
7134 #ifdef PY_RDATA_STATUS_PATCH
7135         PY_RDATA_STATUS_PATCH(&nbt_rdata_status_Type);
7136 #endif
7137 #ifdef PY_RDATA_DATA_PATCH
7138         PY_RDATA_DATA_PATCH(&nbt_rdata_data_Type);
7139 #endif
7140 #ifdef PY_RES_REC_PATCH
7141         PY_RES_REC_PATCH(&nbt_res_rec_Type);
7142 #endif
7143 #ifdef PY_NAME_PACKET_PATCH
7144         PY_NAME_PACKET_PATCH(&nbt_name_packet_Type);
7145 #endif
7146 #ifdef PY_SMB_TRANS_BODY_PATCH
7147         PY_SMB_TRANS_BODY_PATCH(&smb_trans_body_Type);
7148 #endif
7149 #ifdef PY_DGRAM_SMB_PACKET_PATCH
7150         PY_DGRAM_SMB_PACKET_PATCH(&dgram_smb_packet_Type);
7151 #endif
7152 #ifdef PY_DGRAM_MESSAGE_PATCH
7153         PY_DGRAM_MESSAGE_PATCH(&dgram_message_Type);
7154 #endif
7155 #ifdef PY_DGRAM_PACKET_PATCH
7156         PY_DGRAM_PACKET_PATCH(&nbt_dgram_packet_Type);
7157 #endif
7158 #ifdef PY_SOCKADDR_PATCH
7159         PY_SOCKADDR_PATCH(&nbt_sockaddr_Type);
7160 #endif
7161 #ifdef PY_NETLOGON_SAM_LOGON_REQUEST_PATCH
7162         PY_NETLOGON_SAM_LOGON_REQUEST_PATCH(&NETLOGON_SAM_LOGON_REQUEST_Type);
7163 #endif
7164 #ifdef PY_NETLOGON_LOGON_REQUEST_PATCH
7165         PY_NETLOGON_LOGON_REQUEST_PATCH(&NETLOGON_LOGON_REQUEST_Type);
7166 #endif
7167 #ifdef PY_NETLOGON_SAM_LOGON_RESPONSE_NT40_PATCH
7168         PY_NETLOGON_SAM_LOGON_RESPONSE_NT40_PATCH(&NETLOGON_SAM_LOGON_RESPONSE_NT40_Type);
7169 #endif
7170 #ifdef PY_NETLOGON_SAM_LOGON_RESPONSE_PATCH
7171         PY_NETLOGON_SAM_LOGON_RESPONSE_PATCH(&NETLOGON_SAM_LOGON_RESPONSE_Type);
7172 #endif
7173 #ifdef PY_NETLOGON_SAM_LOGON_RESPONSE_EX_PATCH
7174         PY_NETLOGON_SAM_LOGON_RESPONSE_EX_PATCH(&NETLOGON_SAM_LOGON_RESPONSE_EX_Type);
7175 #endif
7176 #ifdef PY_NETLOGON_QUERY_FOR_PDC_PATCH
7177         PY_NETLOGON_QUERY_FOR_PDC_PATCH(&nbt_netlogon_query_for_pdc_Type);
7178 #endif
7179 #ifdef PY_NETLOGON_RESPONSE_FROM_PDC_PATCH
7180         PY_NETLOGON_RESPONSE_FROM_PDC_PATCH(&nbt_netlogon_response_from_pdc_Type);
7181 #endif
7182 #ifdef PY_NETLOGON_RESPONSE2_PATCH
7183         PY_NETLOGON_RESPONSE2_PATCH(&nbt_netlogon_response2_Type);
7184 #endif
7185 #ifdef PY_DB_CHANGE_INFO_PATCH
7186         PY_DB_CHANGE_INFO_PATCH(&nbt_db_change_info_Type);
7187 #endif
7188 #ifdef PY_NETLOGON_DB_CHANGE_PATCH
7189         PY_NETLOGON_DB_CHANGE_PATCH(&NETLOGON_DB_CHANGE_Type);
7190 #endif
7191 #ifdef PY_NETLOGON_PACKET_PATCH
7192         PY_NETLOGON_PACKET_PATCH(&nbt_netlogon_packet_Type);
7193 #endif
7194 #ifdef PY_BROWSE_HOST_ANNOUNCEMENT_PATCH
7195         PY_BROWSE_HOST_ANNOUNCEMENT_PATCH(&nbt_browse_host_announcement_Type);
7196 #endif
7197 #ifdef PY_BROWSE_ANNOUNCEMENT_REQUEST_PATCH
7198         PY_BROWSE_ANNOUNCEMENT_REQUEST_PATCH(&nbt_browse_announcement_request_Type);
7199 #endif
7200 #ifdef PY_BROWSE_ELECTION_REQUEST_PATCH
7201         PY_BROWSE_ELECTION_REQUEST_PATCH(&nbt_browse_election_request_Type);
7202 #endif
7203 #ifdef PY_BROWSE_BACKUP_LIST_REQUEST_PATCH
7204         PY_BROWSE_BACKUP_LIST_REQUEST_PATCH(&nbt_browse_backup_list_request_Type);
7205 #endif
7206 #ifdef PY_BROWSE_BACKUP_LIST_RESPONSE_PATCH
7207         PY_BROWSE_BACKUP_LIST_RESPONSE_PATCH(&nbt_browse_backup_list_response_Type);
7208 #endif
7209 #ifdef PY_BROWSE_BECOME_BACKUP_PATCH
7210         PY_BROWSE_BECOME_BACKUP_PATCH(&nbt_browse_become_backup_Type);
7211 #endif
7212 #ifdef PY_BROWSE_DOMAIN_ANNOUNCEMENT_PATCH
7213         PY_BROWSE_DOMAIN_ANNOUNCEMENT_PATCH(&nbt_browse_domain_announcement_Type);
7214 #endif
7215 #ifdef PY_BROWSE_MASTER_ANNOUNCEMENT_PATCH
7216         PY_BROWSE_MASTER_ANNOUNCEMENT_PATCH(&nbt_browse_master_announcement_Type);
7217 #endif
7218 #ifdef PY_BROWSE_RESET_STATE_PATCH
7219         PY_BROWSE_RESET_STATE_PATCH(&nbt_browse_reset_state_Type);
7220 #endif
7221 #ifdef PY_BROWSE_LOCAL_MASTER_ANNOUNCEMENT_PATCH
7222         PY_BROWSE_LOCAL_MASTER_ANNOUNCEMENT_PATCH(&nbt_browse_local_master_announcement_Type);
7223 #endif
7224 #ifdef PY_BROWSE_PACKET_PATCH
7225         PY_BROWSE_PACKET_PATCH(&nbt_browse_packet_Type);
7226 #endif
7227 #ifdef PY_NBT_PATCH
7228         PY_NBT_PATCH(&nbt_InterfaceType);
7229 #endif
7230
7231         m = Py_InitModule3("nbt", nbt_methods, "nbt DCE/RPC");
7232         if (m == NULL)
7233                 return;
7234
7235         PyModule_AddObject(m, "DGRAM_ERROR_INVALID_DEST", PyInt_FromLong(DGRAM_ERROR_INVALID_DEST));
7236         PyModule_AddObject(m, "NBT_NODE_B", PyInt_FromLong(NBT_NODE_B));
7237         PyModule_AddObject(m, "NBT_DGRAM_SERVICE_PORT", PyInt_FromLong(138));
7238         PyModule_AddObject(m, "DGRAM_QUERY_POSITIVE", PyInt_FromLong(DGRAM_QUERY_POSITIVE));
7239         PyModule_AddObject(m, "LOGON_SAM_LOGON_PAUSE_RESPONSE", PyInt_FromLong(LOGON_SAM_LOGON_PAUSE_RESPONSE));
7240         PyModule_AddObject(m, "NBT_SERVER_CLOSEST", PyInt_FromLong(NBT_SERVER_CLOSEST));
7241         PyModule_AddObject(m, "NBT_SERVER_TIMESERV", PyInt_FromLong(NBT_SERVER_TIMESERV));
7242         PyModule_AddObject(m, "NBT_NM_GROUP", PyInt_FromLong(NBT_NM_GROUP));
7243         PyModule_AddObject(m, "NETLOGON_NT_VERSION_PDC", PyInt_FromLong(NETLOGON_NT_VERSION_PDC));
7244         PyModule_AddObject(m, "GetBackupListResp", PyInt_FromLong(GetBackupListResp));
7245         PyModule_AddObject(m, "LOGON_SAM_LOGON_PAUSE_RESPONSE_EX", PyInt_FromLong(LOGON_SAM_LOGON_PAUSE_RESPONSE_EX));
7246         PyModule_AddObject(m, "NBT_SERVER_GOOD_TIMESERV", PyInt_FromLong(NBT_SERVER_GOOD_TIMESERV));
7247         PyModule_AddObject(m, "NBT_SERVER_DS", PyInt_FromLong(NBT_SERVER_DS));
7248         PyModule_AddObject(m, "NBT_SERVER_SELECT_SECRET_DOMAIN_6", PyInt_FromLong(NBT_SERVER_SELECT_SECRET_DOMAIN_6));
7249         PyModule_AddObject(m, "NBT_QCLASS_IP", PyInt_FromLong(NBT_QCLASS_IP));
7250         PyModule_AddObject(m, "MasterAnnouncement", PyInt_FromLong(MasterAnnouncement));
7251         PyModule_AddObject(m, "NBT_SERVER_ADS_WEB_SERVICE", PyInt_FromLong(NBT_SERVER_ADS_WEB_SERVICE));
7252         PyModule_AddObject(m, "NBT_NAME_BROWSER", PyInt_FromLong(NBT_NAME_BROWSER));
7253         PyModule_AddObject(m, "NBT_RCODE_SVR", PyInt_FromLong(NBT_RCODE_SVR));
7254         PyModule_AddObject(m, "BecomeBackup", PyInt_FromLong(BecomeBackup));
7255         PyModule_AddObject(m, "DGRAM_NODE_NBDD", PyInt_FromLong(DGRAM_NODE_NBDD));
7256         PyModule_AddObject(m, "DomainAnnouncement", PyInt_FromLong(DomainAnnouncement));
7257         PyModule_AddObject(m, "DGRAM_NODE_B", PyInt_FromLong(DGRAM_NODE_B));
7258         PyModule_AddObject(m, "NBT_NAME_PDC", PyInt_FromLong(NBT_NAME_PDC));
7259         PyModule_AddObject(m, "NBT_FLAG_BROADCAST", PyInt_FromLong(NBT_FLAG_BROADCAST));
7260         PyModule_AddObject(m, "NBT_RCODE_CFT", PyInt_FromLong(NBT_RCODE_CFT));
7261         PyModule_AddObject(m, "NETLOGON_NT_VERSION_WITH_CLOSEST_SITE", PyInt_FromLong(NETLOGON_NT_VERSION_WITH_CLOSEST_SITE));
7262         PyModule_AddObject(m, "LOGON_SAM_LOGON_RESPONSE_EX", PyInt_FromLong(LOGON_SAM_LOGON_RESPONSE_EX));
7263         PyModule_AddObject(m, "NBT_SERVER_IS_DEFAULT_NC", PyInt_FromLong(NBT_SERVER_IS_DEFAULT_NC));
7264         PyModule_AddObject(m, "Election", PyInt_FromLong(Election));
7265         PyModule_AddObject(m, "NETLOGON_NT_VERSION_LOCAL", PyInt_FromLong(NETLOGON_NT_VERSION_LOCAL));
7266         PyModule_AddObject(m, "DGRAM_NODE_M", PyInt_FromLong(DGRAM_NODE_M));
7267         PyModule_AddObject(m, "NBT_QTYPE_NETBIOS", PyInt_FromLong(NBT_QTYPE_NETBIOS));
7268         PyModule_AddObject(m, "DGRAM_DIRECT_GROUP", PyInt_FromLong(DGRAM_DIRECT_GROUP));
7269         PyModule_AddObject(m, "NBT_FLAG_REPLY", PyInt_FromLong(NBT_FLAG_REPLY));
7270         PyModule_AddObject(m, "NBT_FLAG_TRUNCATION", PyInt_FromLong(NBT_FLAG_TRUNCATION));
7271         PyModule_AddObject(m, "NBT_FLAG_RECURSION_DESIRED", PyInt_FromLong(NBT_FLAG_RECURSION_DESIRED));
7272         PyModule_AddObject(m, "LOGON_SAM_LOGON_USER_UNKNOWN_EX", PyInt_FromLong(LOGON_SAM_LOGON_USER_UNKNOWN_EX));
7273         PyModule_AddObject(m, "NETLOGON_NT_VERSION_IP", PyInt_FromLong(NETLOGON_NT_VERSION_IP));
7274         PyModule_AddObject(m, "NBT_SERVER_PDC", PyInt_FromLong(NBT_SERVER_PDC));
7275         PyModule_AddObject(m, "LOGON_SAM_LOGON_REQUEST", PyInt_FromLong(LOGON_SAM_LOGON_REQUEST));
7276         PyModule_AddObject(m, "DGRAM_FLAG_NODE_TYPE", PyInt_FromLong(DGRAM_FLAG_NODE_TYPE));
7277         PyModule_AddObject(m, "NBT_RCODE_NAM", PyInt_FromLong(NBT_RCODE_NAM));
7278         PyModule_AddObject(m, "NBT_RCODE_ACT", PyInt_FromLong(NBT_RCODE_ACT));
7279         PyModule_AddObject(m, "NBT_FLAG_AUTHORITATIVE", PyInt_FromLong(NBT_FLAG_AUTHORITATIVE));
7280         PyModule_AddObject(m, "DGRAM_FLAG_FIRST", PyInt_FromLong(DGRAM_FLAG_FIRST));
7281         PyModule_AddObject(m, "NBT_SERVER_KDC", PyInt_FromLong(NBT_SERVER_KDC));
7282         PyModule_AddObject(m, "NBT_OPCODE_REFRESH2", PyInt_FromLong(NBT_OPCODE_REFRESH2));
7283         PyModule_AddObject(m, "NETLOGON_NT_VERSION_5EX_WITH_IP", PyInt_FromLong(NETLOGON_NT_VERSION_5EX_WITH_IP));
7284         PyModule_AddObject(m, "NBT_SERVER_FOREST_ROOT", PyInt_FromLong(NBT_SERVER_FOREST_ROOT));
7285         PyModule_AddObject(m, "NBT_FLAG_RECURSION_AVAIL", PyInt_FromLong(NBT_FLAG_RECURSION_AVAIL));
7286         PyModule_AddObject(m, "NBT_RCODE_RFS", PyInt_FromLong(NBT_RCODE_RFS));
7287         PyModule_AddObject(m, "SMB_TRANSACTION", PyInt_FromLong(SMB_TRANSACTION));
7288         PyModule_AddObject(m, "LOGON_PRIMARY_QUERY", PyInt_FromLong(LOGON_PRIMARY_QUERY));
7289         PyModule_AddObject(m, "NBT_NAME_SERVICE_PORT", PyInt_FromLong(137));
7290         PyModule_AddObject(m, "DGRAM_DIRECT_UNIQUE", PyInt_FromLong(DGRAM_DIRECT_UNIQUE));
7291         PyModule_AddObject(m, "LOGON_SAM_LOGON_USER_UNKNOWN", PyInt_FromLong(LOGON_SAM_LOGON_USER_UNKNOWN));
7292         PyModule_AddObject(m, "NETLOGON_NT_VERSION_AVOID_NT4EMUL", PyInt_FromLong(NETLOGON_NT_VERSION_AVOID_NT4EMUL));
7293         PyModule_AddObject(m, "DGRAM_ERROR_INVALID_SOURCE", PyInt_FromLong(DGRAM_ERROR_INVALID_SOURCE));
7294         PyModule_AddObject(m, "NBT_SERVER_LDAP", PyInt_FromLong(NBT_SERVER_LDAP));
7295         PyModule_AddObject(m, "NBT_NAME_LOGON", PyInt_FromLong(NBT_NAME_LOGON));
7296         PyModule_AddObject(m, "NBT_NODE_H", PyInt_FromLong(NBT_NODE_H));
7297         PyModule_AddObject(m, "NBT_OPCODE_REGISTER", PyInt_FromLong(NBT_OPCODE_REGISTER));
7298         PyModule_AddObject(m, "DGRAM_BCAST", PyInt_FromLong(DGRAM_BCAST));
7299         PyModule_AddObject(m, "NBT_SERVER_GC", PyInt_FromLong(NBT_SERVER_GC));
7300         PyModule_AddObject(m, "NBT_OPCODE_MULTI_HOME_REG", PyInt_FromLong(NBT_OPCODE_MULTI_HOME_REG));
7301         PyModule_AddObject(m, "DGRAM_QUERY_NEGATIVE", PyInt_FromLong(DGRAM_QUERY_NEGATIVE));
7302         PyModule_AddObject(m, "NETLOGON_RESPONSE_FROM_PDC", PyInt_FromLong(NETLOGON_RESPONSE_FROM_PDC));
7303         PyModule_AddObject(m, "NBT_OPCODE_RELEASE", PyInt_FromLong(NBT_OPCODE_RELEASE));
7304         PyModule_AddObject(m, "NBT_QTYPE_NULL", PyInt_FromLong(NBT_QTYPE_NULL));
7305         PyModule_AddObject(m, "NBT_NODE_P", PyInt_FromLong(NBT_NODE_P));
7306         PyModule_AddObject(m, "NBT_NODE_M", PyInt_FromLong(NBT_NODE_M));
7307         PyModule_AddObject(m, "NETLOGON_NT_VERSION_1", PyInt_FromLong(NETLOGON_NT_VERSION_1));
7308         PyModule_AddObject(m, "NBT_SERVER_FULL_SECRET_DOMAIN_6", PyInt_FromLong(NBT_SERVER_FULL_SECRET_DOMAIN_6));
7309         PyModule_AddObject(m, "NBT_SERVER_NDNC", PyInt_FromLong(NBT_SERVER_NDNC));
7310         PyModule_AddObject(m, "NBT_OPCODE_WACK", PyInt_FromLong(NBT_OPCODE_WACK));
7311         PyModule_AddObject(m, "NBT_NAME_CLIENT", PyInt_FromLong(NBT_NAME_CLIENT));
7312         PyModule_AddObject(m, "NBT_NAME_SERVER", PyInt_FromLong(NBT_NAME_SERVER));
7313         PyModule_AddObject(m, "NBT_NAME_MS", PyInt_FromLong(NBT_NAME_MS));
7314         PyModule_AddObject(m, "NBT_RCODE_OK", PyInt_FromLong(NBT_RCODE_OK));
7315         PyModule_AddObject(m, "NBT_RCODE_FMT", PyInt_FromLong(NBT_RCODE_FMT));
7316         PyModule_AddObject(m, "NBT_OPCODE", PyInt_FromLong(NBT_OPCODE));
7317         PyModule_AddObject(m, "NBT_OPCODE_QUERY", PyInt_FromLong(NBT_OPCODE_QUERY));
7318         PyModule_AddObject(m, "NBT_NM_OWNER_TYPE", PyInt_FromLong(NBT_NM_OWNER_TYPE));
7319         PyModule_AddObject(m, "DGRAM_ERROR_NAME_NOT_PRESENT", PyInt_FromLong(DGRAM_ERROR_NAME_NOT_PRESENT));
7320         PyModule_AddObject(m, "NBT_QTYPE_NAMESERVICE", PyInt_FromLong(NBT_QTYPE_NAMESERVICE));
7321         PyModule_AddObject(m, "NBT_NM_ACTIVE", PyInt_FromLong(NBT_NM_ACTIVE));
7322         PyModule_AddObject(m, "LOGON_SAM_LOGON_RESPONSE", PyInt_FromLong(LOGON_SAM_LOGON_RESPONSE));
7323         PyModule_AddObject(m, "NBT_NM_CONFLICT", PyInt_FromLong(NBT_NM_CONFLICT));
7324         PyModule_AddObject(m, "DGRAM_SMB", PyInt_FromLong(0xff534d42));
7325         PyModule_AddObject(m, "NBT_NM_PERMANENT", PyInt_FromLong(NBT_NM_PERMANENT));
7326         PyModule_AddObject(m, "LocalMasterAnnouncement", PyInt_FromLong(LocalMasterAnnouncement));
7327         PyModule_AddObject(m, "NETLOGON_NT_VERSION_GC", PyInt_FromLong(NETLOGON_NT_VERSION_GC));
7328         PyModule_AddObject(m, "DGRAM_ERROR", PyInt_FromLong(DGRAM_ERROR));
7329         PyModule_AddObject(m, "ResetBrowserState", PyInt_FromLong(ResetBrowserState));
7330         PyModule_AddObject(m, "DGRAM_NODE_P", PyInt_FromLong(DGRAM_NODE_P));
7331         PyModule_AddObject(m, "NBT_MAILSLOT_GETDC", PyString_FromString("\\MAILSLOT\\NET\\GETDC"));
7332         PyModule_AddObject(m, "NBT_NM_DEREGISTER", PyInt_FromLong(NBT_NM_DEREGISTER));
7333         PyModule_AddObject(m, "NETLOGON_ANNOUNCE_UAS", PyInt_FromLong(NETLOGON_ANNOUNCE_UAS));
7334         PyModule_AddObject(m, "NETLOGON_NT_VERSION_5", PyInt_FromLong(NETLOGON_NT_VERSION_5));
7335         PyModule_AddObject(m, "LOGON_RESPONSE2", PyInt_FromLong(LOGON_RESPONSE2));
7336         PyModule_AddObject(m, "DGRAM_FLAG_MORE", PyInt_FromLong(DGRAM_FLAG_MORE));
7337         PyModule_AddObject(m, "HostAnnouncement", PyInt_FromLong(HostAnnouncement));
7338         PyModule_AddObject(m, "NBT_OPCODE_REFRESH", PyInt_FromLong(NBT_OPCODE_REFRESH));
7339         PyModule_AddObject(m, "NBT_SERVER_HAS_DNS_NAME", PyInt_FromLong(NBT_SERVER_HAS_DNS_NAME));
7340         PyModule_AddObject(m, "NBT_RCODE_IMP", PyInt_FromLong(NBT_RCODE_IMP));
7341         PyModule_AddObject(m, "NBT_SERVER_WRITABLE", PyInt_FromLong(NBT_SERVER_WRITABLE));
7342         PyModule_AddObject(m, "NBT_MAILSLOT_NTLOGON", PyString_FromString("\\MAILSLOT\\NET\\NTLOGON"));
7343         PyModule_AddObject(m, "DGRAM_QUERY", PyInt_FromLong(DGRAM_QUERY));
7344         PyModule_AddObject(m, "AnnouncementRequest", PyInt_FromLong(AnnouncementRequest));
7345         PyModule_AddObject(m, "LOGON_REQUEST", PyInt_FromLong(LOGON_REQUEST));
7346         PyModule_AddObject(m, "NBT_QTYPE_ADDRESS", PyInt_FromLong(NBT_QTYPE_ADDRESS));
7347         PyModule_AddObject(m, "GetBackupListReq", PyInt_FromLong(GetBackupListReq));
7348         PyModule_AddObject(m, "NBT_RCODE", PyInt_FromLong(NBT_RCODE));
7349         PyModule_AddObject(m, "NETLOGON_NT_VERSION_5EX", PyInt_FromLong(NETLOGON_NT_VERSION_5EX));
7350         PyModule_AddObject(m, "NBT_NAME_MASTER", PyInt_FromLong(NBT_NAME_MASTER));
7351         PyModule_AddObject(m, "NBT_QTYPE_STATUS", PyInt_FromLong(NBT_QTYPE_STATUS));
7352         PyModule_AddObject(m, "NBT_MAILSLOT_BROWSE", PyString_FromString("\\MAILSLOT\\BROWSE"));
7353         PyModule_AddObject(m, "NBT_NAME_USER", PyInt_FromLong(NBT_NAME_USER));
7354         PyModule_AddObject(m, "NBT_MAILSLOT_NETLOGON", PyString_FromString("\\MAILSLOT\\NET\\NETLOGON"));
7355         Py_INCREF((PyObject *)(void *)&nbt_name_Type);
7356         PyModule_AddObject(m, "name", (PyObject *)(void *)&nbt_name_Type);
7357         Py_INCREF((PyObject *)(void *)&nbt_name_question_Type);
7358         PyModule_AddObject(m, "name_question", (PyObject *)(void *)&nbt_name_question_Type);
7359         Py_INCREF((PyObject *)(void *)&nbt_rdata_address_Type);
7360         PyModule_AddObject(m, "rdata_address", (PyObject *)(void *)&nbt_rdata_address_Type);
7361         Py_INCREF((PyObject *)(void *)&nbt_rdata_netbios_Type);
7362         PyModule_AddObject(m, "rdata_netbios", (PyObject *)(void *)&nbt_rdata_netbios_Type);
7363         Py_INCREF((PyObject *)(void *)&nbt_statistics_Type);
7364         PyModule_AddObject(m, "statistics", (PyObject *)(void *)&nbt_statistics_Type);
7365         Py_INCREF((PyObject *)(void *)&nbt_status_name_Type);
7366         PyModule_AddObject(m, "status_name", (PyObject *)(void *)&nbt_status_name_Type);
7367         Py_INCREF((PyObject *)(void *)&nbt_rdata_status_Type);
7368         PyModule_AddObject(m, "rdata_status", (PyObject *)(void *)&nbt_rdata_status_Type);
7369         Py_INCREF((PyObject *)(void *)&nbt_rdata_data_Type);
7370         PyModule_AddObject(m, "rdata_data", (PyObject *)(void *)&nbt_rdata_data_Type);
7371         Py_INCREF((PyObject *)(void *)&nbt_res_rec_Type);
7372         PyModule_AddObject(m, "res_rec", (PyObject *)(void *)&nbt_res_rec_Type);
7373         Py_INCREF((PyObject *)(void *)&nbt_name_packet_Type);
7374         PyModule_AddObject(m, "name_packet", (PyObject *)(void *)&nbt_name_packet_Type);
7375         Py_INCREF((PyObject *)(void *)&smb_trans_body_Type);
7376         PyModule_AddObject(m, "smb_trans_body", (PyObject *)(void *)&smb_trans_body_Type);
7377         Py_INCREF((PyObject *)(void *)&dgram_smb_packet_Type);
7378         PyModule_AddObject(m, "dgram_smb_packet", (PyObject *)(void *)&dgram_smb_packet_Type);
7379         Py_INCREF((PyObject *)(void *)&dgram_message_Type);
7380         PyModule_AddObject(m, "dgram_message", (PyObject *)(void *)&dgram_message_Type);
7381         Py_INCREF((PyObject *)(void *)&nbt_dgram_packet_Type);
7382         PyModule_AddObject(m, "dgram_packet", (PyObject *)(void *)&nbt_dgram_packet_Type);
7383         Py_INCREF((PyObject *)(void *)&nbt_sockaddr_Type);
7384         PyModule_AddObject(m, "sockaddr", (PyObject *)(void *)&nbt_sockaddr_Type);
7385         Py_INCREF((PyObject *)(void *)&NETLOGON_SAM_LOGON_REQUEST_Type);
7386         PyModule_AddObject(m, "NETLOGON_SAM_LOGON_REQUEST", (PyObject *)(void *)&NETLOGON_SAM_LOGON_REQUEST_Type);
7387         Py_INCREF((PyObject *)(void *)&NETLOGON_LOGON_REQUEST_Type);
7388         PyModule_AddObject(m, "NETLOGON_LOGON_REQUEST", (PyObject *)(void *)&NETLOGON_LOGON_REQUEST_Type);
7389         Py_INCREF((PyObject *)(void *)&NETLOGON_SAM_LOGON_RESPONSE_NT40_Type);
7390         PyModule_AddObject(m, "NETLOGON_SAM_LOGON_RESPONSE_NT40", (PyObject *)(void *)&NETLOGON_SAM_LOGON_RESPONSE_NT40_Type);
7391         Py_INCREF((PyObject *)(void *)&NETLOGON_SAM_LOGON_RESPONSE_Type);
7392         PyModule_AddObject(m, "NETLOGON_SAM_LOGON_RESPONSE", (PyObject *)(void *)&NETLOGON_SAM_LOGON_RESPONSE_Type);
7393         Py_INCREF((PyObject *)(void *)&NETLOGON_SAM_LOGON_RESPONSE_EX_Type);
7394         PyModule_AddObject(m, "NETLOGON_SAM_LOGON_RESPONSE_EX", (PyObject *)(void *)&NETLOGON_SAM_LOGON_RESPONSE_EX_Type);
7395         Py_INCREF((PyObject *)(void *)&nbt_netlogon_query_for_pdc_Type);
7396         PyModule_AddObject(m, "netlogon_query_for_pdc", (PyObject *)(void *)&nbt_netlogon_query_for_pdc_Type);
7397         Py_INCREF((PyObject *)(void *)&nbt_netlogon_response_from_pdc_Type);
7398         PyModule_AddObject(m, "netlogon_response_from_pdc", (PyObject *)(void *)&nbt_netlogon_response_from_pdc_Type);
7399         Py_INCREF((PyObject *)(void *)&nbt_netlogon_response2_Type);
7400         PyModule_AddObject(m, "netlogon_response2", (PyObject *)(void *)&nbt_netlogon_response2_Type);
7401         Py_INCREF((PyObject *)(void *)&nbt_db_change_info_Type);
7402         PyModule_AddObject(m, "db_change_info", (PyObject *)(void *)&nbt_db_change_info_Type);
7403         Py_INCREF((PyObject *)(void *)&NETLOGON_DB_CHANGE_Type);
7404         PyModule_AddObject(m, "NETLOGON_DB_CHANGE", (PyObject *)(void *)&NETLOGON_DB_CHANGE_Type);
7405         Py_INCREF((PyObject *)(void *)&nbt_netlogon_packet_Type);
7406         PyModule_AddObject(m, "netlogon_packet", (PyObject *)(void *)&nbt_netlogon_packet_Type);
7407         Py_INCREF((PyObject *)(void *)&nbt_browse_host_announcement_Type);
7408         PyModule_AddObject(m, "browse_host_announcement", (PyObject *)(void *)&nbt_browse_host_announcement_Type);
7409         Py_INCREF((PyObject *)(void *)&nbt_browse_announcement_request_Type);
7410         PyModule_AddObject(m, "browse_announcement_request", (PyObject *)(void *)&nbt_browse_announcement_request_Type);
7411         Py_INCREF((PyObject *)(void *)&nbt_browse_election_request_Type);
7412         PyModule_AddObject(m, "browse_election_request", (PyObject *)(void *)&nbt_browse_election_request_Type);
7413         Py_INCREF((PyObject *)(void *)&nbt_browse_backup_list_request_Type);
7414         PyModule_AddObject(m, "browse_backup_list_request", (PyObject *)(void *)&nbt_browse_backup_list_request_Type);
7415         Py_INCREF((PyObject *)(void *)&nbt_browse_backup_list_response_Type);
7416         PyModule_AddObject(m, "browse_backup_list_response", (PyObject *)(void *)&nbt_browse_backup_list_response_Type);
7417         Py_INCREF((PyObject *)(void *)&nbt_browse_become_backup_Type);
7418         PyModule_AddObject(m, "browse_become_backup", (PyObject *)(void *)&nbt_browse_become_backup_Type);
7419         Py_INCREF((PyObject *)(void *)&nbt_browse_domain_announcement_Type);
7420         PyModule_AddObject(m, "browse_domain_announcement", (PyObject *)(void *)&nbt_browse_domain_announcement_Type);
7421         Py_INCREF((PyObject *)(void *)&nbt_browse_master_announcement_Type);
7422         PyModule_AddObject(m, "browse_master_announcement", (PyObject *)(void *)&nbt_browse_master_announcement_Type);
7423         Py_INCREF((PyObject *)(void *)&nbt_browse_reset_state_Type);
7424         PyModule_AddObject(m, "browse_reset_state", (PyObject *)(void *)&nbt_browse_reset_state_Type);
7425         Py_INCREF((PyObject *)(void *)&nbt_browse_local_master_announcement_Type);
7426         PyModule_AddObject(m, "browse_local_master_announcement", (PyObject *)(void *)&nbt_browse_local_master_announcement_Type);
7427         Py_INCREF((PyObject *)(void *)&nbt_browse_packet_Type);
7428         PyModule_AddObject(m, "browse_packet", (PyObject *)(void *)&nbt_browse_packet_Type);
7429         Py_INCREF((PyObject *)(void *)&nbt_InterfaceType);
7430         PyModule_AddObject(m, "nbt", (PyObject *)(void *)&nbt_InterfaceType);
7431 #ifdef PY_MOD_NBT_PATCH
7432         PY_MOD_NBT_PATCH(m);
7433 #endif
7434
7435 }